htmlnano 2.1.5 → 3.1.0

package/dist/_modules/minifyAttributes.js

@@ -0,0 +1,159 @@
+Object.defineProperty(exports, '__esModule', { value: true });
+
+var helpers_js = require('../helpers.js');
+var collapseAttributeWhitespace_js = require('./collapseAttributeWhitespace.js');
+
+const asciiWhitespace = new Set([
+    '\t',
+    '\n',
+    '\f',
+    '\r',
+    ' '
+]);
+const defaultOptions = {
+    metaContent: true,
+    redundantWhitespaces: 'safe'
+};
+function isAsciiWhitespace(char) {
+    return asciiWhitespace.has(char);
+}
+function isAsciiDigit(char) {
+    return char >= '0' && char <= '9';
+}
+function skipAsciiWhitespace(input, start) {
+    let pos = start;
+    while(pos < input.length && isAsciiWhitespace(input[pos])){
+        pos += 1;
+    }
+    return pos;
+}
+function minifyMetaRefreshValue(value) {
+    const input = value;
+    let pos = skipAsciiWhitespace(input, 0);
+    const timeStart = pos;
+    while(pos < input.length && isAsciiDigit(input[pos])){
+        pos += 1;
+    }
+    if (pos === timeStart) return null;
+    const time = input.slice(timeStart, pos);
+    while(pos < input.length){
+        const ch = input[pos];
+        if (isAsciiDigit(ch) || ch === '.') {
+            pos += 1;
+            continue;
+        }
+        break;
+    }
+    pos = skipAsciiWhitespace(input, pos);
+    if (pos >= input.length) return time;
+    const separator = input[pos];
+    if (separator !== ';' && separator !== ',') return null;
+    pos += 1;
+    pos = skipAsciiWhitespace(input, pos);
+    if (pos >= input.length) return time;
+    let hasUrlPrefix = false;
+    if (input[pos] === 'u' || input[pos] === 'U') {
+        if (pos + 2 < input.length) {
+            const maybeUrl = input.slice(pos, pos + 3);
+            if (maybeUrl.toLowerCase() === 'url') {
+                let prefixPos = skipAsciiWhitespace(input, pos + 3);
+                if (prefixPos < input.length && input[prefixPos] === '=') {
+                    prefixPos = skipAsciiWhitespace(input, prefixPos + 1);
+                    hasUrlPrefix = true;
+                    pos = prefixPos;
+                }
+            }
+        }
+    }
+    if (pos >= input.length) return time;
+    const firstUrlChar = input[pos];
+    if (firstUrlChar === '"' || firstUrlChar === '\'') {
+        if (!hasUrlPrefix) return null;
+        const quote = firstUrlChar;
+        const urlStart = pos + 1;
+        const quoteIndex = input.indexOf(quote, urlStart);
+        const url = quoteIndex === -1 ? input.slice(urlStart) : input.slice(urlStart, quoteIndex);
+        if (!url) return time;
+        const closingQuote = quoteIndex === -1 ? '' : quote;
+        return `${time}${separator} URL=${quote}${url}${closingQuote}`;
+    }
+    const url = input.slice(pos).trim();
+    if (!url) return time;
+    return `${time}${separator} ${url}`;
+}
+function isMetaRefresh(attrs, tagName) {
+    if (!tagName || tagName.toLowerCase() !== 'meta') return false;
+    const httpEquiv = attrs['http-equiv'];
+    if (typeof httpEquiv !== 'string') return false;
+    return httpEquiv.trim().toLowerCase() === 'refresh';
+}
+function normalizeOptions(moduleOptions) {
+    if (moduleOptions && typeof moduleOptions === 'object') {
+        let redundantWhitespaces = defaultOptions.redundantWhitespaces;
+        if (moduleOptions.redundantWhitespaces === 'aggressive') {
+            redundantWhitespaces = 'agressive';
+        } else if (moduleOptions.redundantWhitespaces === 'safe' || moduleOptions.redundantWhitespaces === 'agressive' || moduleOptions.redundantWhitespaces === false) {
+            redundantWhitespaces = moduleOptions.redundantWhitespaces;
+        }
+        return {
+            metaContent: moduleOptions.metaContent !== false,
+            redundantWhitespaces
+        };
+    }
+    return defaultOptions;
+}
+function collapseWhitespace(value) {
+    return value.replace(/\s+/g, ' ').trim();
+}
+function minifyAttributeWhitespace(mode, attrName, attrValue, tagName) {
+    if (!mode) {
+        return null;
+    }
+    const attrNameLower = attrName.toLowerCase();
+    if (collapseAttributeWhitespace_js.isListAttribute(attrNameLower, tagName)) {
+        const collapsed = collapseWhitespace(attrValue);
+        return collapsed === attrValue ? null : collapsed;
+    }
+    if (helpers_js.isEventHandler(attrName)) {
+        const trimmed = attrValue.trim();
+        return trimmed === attrValue ? null : trimmed;
+    }
+    if (collapseAttributeWhitespace_js.isSingleValueAttribute(attrNameLower, tagName)) {
+        const trimmed = attrValue.trim();
+        return trimmed === attrValue ? null : trimmed;
+    }
+    if (mode === 'agressive') {
+        const trimmed = attrValue.trim();
+        return trimmed === attrValue ? null : trimmed;
+    }
+    return null;
+}
+const mod = {
+    onAttrs (_options, moduleOptions) {
+        const normalizedOptions = normalizeOptions(moduleOptions);
+        return (attrs, node)=>{
+            if (normalizedOptions.metaContent && isMetaRefresh(attrs, node.tag)) {
+                const content = attrs.content;
+                if (typeof content === 'string') {
+                    const minified = minifyMetaRefreshValue(content);
+                    if (minified !== null && minified !== content) {
+                        attrs.content = minified;
+                    }
+                }
+            }
+            if (normalizedOptions.redundantWhitespaces) {
+                const tagName = node.tag ? node.tag.toLowerCase() : undefined;
+                Object.entries(attrs).forEach(([attrName, attrValue])=>{
+                    if (typeof attrValue !== 'string') return;
+                    const minified = minifyAttributeWhitespace(normalizedOptions.redundantWhitespaces, attrName, attrValue, tagName);
+                    if (minified !== null) {
+                        attrs[attrName] = minified;
+                    }
+                });
+            }
+            return attrs;
+        };
+    }
+};
+
+exports.default = mod;

package/dist/_modules/minifyAttributes.mjs

@@ -0,0 +1,157 @@
+import { isEventHandler } from '../helpers.mjs';
+import { isListAttribute, isSingleValueAttribute } from './collapseAttributeWhitespace.mjs';
+
+const asciiWhitespace = new Set([
+    '\t',
+    '\n',
+    '\f',
+    '\r',
+    ' '
+]);
+const defaultOptions = {
+    metaContent: true,
+    redundantWhitespaces: 'safe'
+};
+function isAsciiWhitespace(char) {
+    return asciiWhitespace.has(char);
+}
+function isAsciiDigit(char) {
+    return char >= '0' && char <= '9';
+}
+function skipAsciiWhitespace(input, start) {
+    let pos = start;
+    while(pos < input.length && isAsciiWhitespace(input[pos])){
+        pos += 1;
+    }
+    return pos;
+}
+function minifyMetaRefreshValue(value) {
+    const input = value;
+    let pos = skipAsciiWhitespace(input, 0);
+    const timeStart = pos;
+    while(pos < input.length && isAsciiDigit(input[pos])){
+        pos += 1;
+    }
+    if (pos === timeStart) return null;
+    const time = input.slice(timeStart, pos);
+    while(pos < input.length){
+        const ch = input[pos];
+        if (isAsciiDigit(ch) || ch === '.') {
+            pos += 1;
+            continue;
+        }
+        break;
+    }
+    pos = skipAsciiWhitespace(input, pos);
+    if (pos >= input.length) return time;
+    const separator = input[pos];
+    if (separator !== ';' && separator !== ',') return null;
+    pos += 1;
+    pos = skipAsciiWhitespace(input, pos);
+    if (pos >= input.length) return time;
+    let hasUrlPrefix = false;
+    if (input[pos] === 'u' || input[pos] === 'U') {
+        if (pos + 2 < input.length) {
+            const maybeUrl = input.slice(pos, pos + 3);
+            if (maybeUrl.toLowerCase() === 'url') {
+                let prefixPos = skipAsciiWhitespace(input, pos + 3);
+                if (prefixPos < input.length && input[prefixPos] === '=') {
+                    prefixPos = skipAsciiWhitespace(input, prefixPos + 1);
+                    hasUrlPrefix = true;
+                    pos = prefixPos;
+                }
+            }
+        }
+    }
+    if (pos >= input.length) return time;
+    const firstUrlChar = input[pos];
+    if (firstUrlChar === '"' || firstUrlChar === '\'') {
+        if (!hasUrlPrefix) return null;
+        const quote = firstUrlChar;
+        const urlStart = pos + 1;
+        const quoteIndex = input.indexOf(quote, urlStart);
+        const url = quoteIndex === -1 ? input.slice(urlStart) : input.slice(urlStart, quoteIndex);
+        if (!url) return time;
+        const closingQuote = quoteIndex === -1 ? '' : quote;
+        return `${time}${separator} URL=${quote}${url}${closingQuote}`;
+    }
+    const url = input.slice(pos).trim();
+    if (!url) return time;
+    return `${time}${separator} ${url}`;
+}
+function isMetaRefresh(attrs, tagName) {
+    if (!tagName || tagName.toLowerCase() !== 'meta') return false;
+    const httpEquiv = attrs['http-equiv'];
+    if (typeof httpEquiv !== 'string') return false;
+    return httpEquiv.trim().toLowerCase() === 'refresh';
+}
+function normalizeOptions(moduleOptions) {
+    if (moduleOptions && typeof moduleOptions === 'object') {
+        let redundantWhitespaces = defaultOptions.redundantWhitespaces;
+        if (moduleOptions.redundantWhitespaces === 'aggressive') {
+            redundantWhitespaces = 'agressive';
+        } else if (moduleOptions.redundantWhitespaces === 'safe' || moduleOptions.redundantWhitespaces === 'agressive' || moduleOptions.redundantWhitespaces === false) {
+            redundantWhitespaces = moduleOptions.redundantWhitespaces;
+        }
+        return {
+            metaContent: moduleOptions.metaContent !== false,
+            redundantWhitespaces
+        };
+    }
+    return defaultOptions;
+}
+function collapseWhitespace(value) {
+    return value.replace(/\s+/g, ' ').trim();
+}
+function minifyAttributeWhitespace(mode, attrName, attrValue, tagName) {
+    if (!mode) {
+        return null;
+    }
+    const attrNameLower = attrName.toLowerCase();
+    if (isListAttribute(attrNameLower, tagName)) {
+        const collapsed = collapseWhitespace(attrValue);
+        return collapsed === attrValue ? null : collapsed;
+    }
+    if (isEventHandler(attrName)) {
+        const trimmed = attrValue.trim();
+        return trimmed === attrValue ? null : trimmed;
+    }
+    if (isSingleValueAttribute(attrNameLower, tagName)) {
+        const trimmed = attrValue.trim();
+        return trimmed === attrValue ? null : trimmed;
+    }
+    if (mode === 'agressive') {
+        const trimmed = attrValue.trim();
+        return trimmed === attrValue ? null : trimmed;
+    }
+    return null;
+}
+const mod = {
+    onAttrs (_options, moduleOptions) {
+        const normalizedOptions = normalizeOptions(moduleOptions);
+        return (attrs, node)=>{
+            if (normalizedOptions.metaContent && isMetaRefresh(attrs, node.tag)) {
+                const content = attrs.content;
+                if (typeof content === 'string') {
+                    const minified = minifyMetaRefreshValue(content);
+                    if (minified !== null && minified !== content) {
+                        attrs.content = minified;
+                    }
+                }
+            }
+            if (normalizedOptions.redundantWhitespaces) {
+                const tagName = node.tag ? node.tag.toLowerCase() : undefined;
+                Object.entries(attrs).forEach(([attrName, attrValue])=>{
+                    if (typeof attrValue !== 'string') return;
+                    const minified = minifyAttributeWhitespace(normalizedOptions.redundantWhitespaces, attrName, attrValue, tagName);
+                    if (minified !== null) {
+                        attrs[attrName] = minified;
+                    }
+                });
+            }
+            return attrs;
+        };
+    }
+};
+
+export { mod as default };

package/dist/_modules/minifyConditionalComments.d.mts

@@ -2,18 +2,27 @@ import PostHTML from 'posthtml';
 import { MinifyOptions } from 'terser';
 import { Options } from 'cssnano';
 import { Config } from 'svgo';
+import { UserDefinedOptions } from 'purgecss';
 
 type PostHTMLTreeLike = [PostHTML.Node] & PostHTML.NodeAPI & {
     options?: {
         quoteAllAttributes?: boolean | undefined;
+        quoteStyle?: 0 | 1 | 2 | undefined;
+        replaceQuote?: boolean | undefined;
     } | undefined;
     render(): string;
     render(node: PostHTML.Node | PostHTMLTreeLike, renderOptions?: any): string;
 };
 type MaybeArray<T> = T | Array<T>;
 type PostHTMLNodeLike = PostHTML.Node | string;
+type HtmlnanoTemplateRule = {
+    tag: string;
+    attrs?: Record<string, string | boolean | void>;
+};
+type MinifyHtmlTemplateOptions = boolean | HtmlnanoTemplateRule[];
 interface HtmlnanoOptions {
     skipConfigLoading?: boolean;
+    configPath?: string;
     skipInternalWarnings?: boolean;
     collapseAttributeWhitespace?: boolean;
     collapseBooleanAttributes?: {
@@ -26,17 +35,42 @@ interface HtmlnanoOptions {
     mergeStyles?: boolean;
     mergeScripts?: boolean;
     minifyCss?: Options | boolean;
+    minifyHtmlTemplate?: MinifyHtmlTemplateOptions;
     minifyConditionalComments?: boolean;
     minifyJs?: MinifyOptions | boolean;
     minifyJson?: boolean;
+    minifyAttributes?: boolean | {
+        metaContent?: boolean;
+        redundantWhitespaces?: 'safe' | 'agressive' | false;
+    };
     minifySvg?: Config | boolean;
     normalizeAttributeValues?: boolean;
-    removeAttributeQuotes?: boolean;
-    removeComments?: boolean | 'safe' | 'all' | RegExp | ((comment: string) => boolean);
+    removeAttributeQuotes?: boolean | {
+        force?: boolean;
+    };
+    removeComments?: boolean | RegExp | ((comment: string) => boolean) | string;
     removeEmptyAttributes?: boolean;
+    removeEmptyElements?: boolean | {
+        removeWithAttributes?: boolean;
+    };
     removeRedundantAttributes?: boolean;
     removeOptionalTags?: boolean;
-    removeUnusedCss?: boolean;
+    removeUnusedCss?: boolean | ({
+        tool: 'purgeCSS';
+    } & Omit<UserDefinedOptions, 'content' | 'css' | 'extractors'>) | {
+        banner?: boolean;
+        csspath?: string;
+        htmlroot?: string;
+        ignore?: (string | RegExp)[];
+        inject?: string;
+        jsdom?: object;
+        media?: string[];
+        report?: boolean;
+        strictSSL?: boolean;
+        timeout?: number;
+        uncssrc?: string;
+        userAgent?: string;
+    };
     sortAttributes?: boolean | 'alphabetical' | 'frequency';
     sortAttributesWithLists?: boolean | 'alphabetical' | 'frequency';
 }

package/dist/_modules/minifyConditionalComments.d.ts

@@ -2,18 +2,27 @@ import PostHTML from 'posthtml';
 import { MinifyOptions } from 'terser';
 import { Options } from 'cssnano';
 import { Config } from 'svgo';
+import { UserDefinedOptions } from 'purgecss';
 
 type PostHTMLTreeLike = [PostHTML.Node] & PostHTML.NodeAPI & {
     options?: {
         quoteAllAttributes?: boolean | undefined;
+        quoteStyle?: 0 | 1 | 2 | undefined;
+        replaceQuote?: boolean | undefined;
     } | undefined;
     render(): string;
     render(node: PostHTML.Node | PostHTMLTreeLike, renderOptions?: any): string;
 };
 type MaybeArray<T> = T | Array<T>;
 type PostHTMLNodeLike = PostHTML.Node | string;
+type HtmlnanoTemplateRule = {
+    tag: string;
+    attrs?: Record<string, string | boolean | void>;
+};
+type MinifyHtmlTemplateOptions = boolean | HtmlnanoTemplateRule[];
 interface HtmlnanoOptions {
     skipConfigLoading?: boolean;
+    configPath?: string;
     skipInternalWarnings?: boolean;
     collapseAttributeWhitespace?: boolean;
     collapseBooleanAttributes?: {
@@ -26,17 +35,42 @@ interface HtmlnanoOptions {
     mergeStyles?: boolean;
     mergeScripts?: boolean;
     minifyCss?: Options | boolean;
+    minifyHtmlTemplate?: MinifyHtmlTemplateOptions;
     minifyConditionalComments?: boolean;
     minifyJs?: MinifyOptions | boolean;
     minifyJson?: boolean;
+    minifyAttributes?: boolean | {
+        metaContent?: boolean;
+        redundantWhitespaces?: 'safe' | 'agressive' | false;
+    };
     minifySvg?: Config | boolean;
     normalizeAttributeValues?: boolean;
-    removeAttributeQuotes?: boolean;
-    removeComments?: boolean | 'safe' | 'all' | RegExp | ((comment: string) => boolean);
+    removeAttributeQuotes?: boolean | {
+        force?: boolean;
+    };
+    removeComments?: boolean | RegExp | ((comment: string) => boolean) | string;
     removeEmptyAttributes?: boolean;
+    removeEmptyElements?: boolean | {
+        removeWithAttributes?: boolean;
+    };
     removeRedundantAttributes?: boolean;
     removeOptionalTags?: boolean;
-    removeUnusedCss?: boolean;
+    removeUnusedCss?: boolean | ({
+        tool: 'purgeCSS';
+    } & Omit<UserDefinedOptions, 'content' | 'css' | 'extractors'>) | {
+        banner?: boolean;
+        csspath?: string;
+        htmlroot?: string;
+        ignore?: (string | RegExp)[];
+        inject?: string;
+        jsdom?: object;
+        media?: string[];
+        report?: boolean;
+        strictSSL?: boolean;
+        timeout?: number;
+        uncssrc?: string;
+        userAgent?: string;
+    };
     sortAttributes?: boolean | 'alphabetical' | 'frequency';
     sortAttributesWithLists?: boolean | 'alphabetical' | 'frequency';
 }

package/dist/_modules/minifyConditionalComments.js

@@ -8,14 +8,15 @@ function _interopDefault (e) { return e && e.__esModule ? e : { default: e }; }
 var htmlnano__default = /*#__PURE__*/_interopDefault(htmlnano);
 
 // 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;
+const CONDITIONAL_COMMENT_HIDDEN_REGEXP = /(<!--\[if\s+?[^<>[\]]+?]>)([\s\S]*?)(<!\[endif\]-->)/gm;
+const CONDITIONAL_COMMENT_REVEALED_REGEXP = /(<!--\[if\s+?[^<>[\]]+?\]><!-->)([\s\S]*?)(<!--<!\[endif\]-->)/gm;
 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') {
             if (helpers_js.isConditionalComment(node)) {
-                tree[i] = await minifycontentInsideConditionalComments(node, htmlnanoOptions);
+                tree[i] = await minifyContentInsideConditionalComments(node, htmlnanoOptions);
             }
         } else if (node.content && node.content.length) {
             node.content = await minifyConditionalComments(node.content, htmlnanoOptions);
@@ -26,29 +27,46 @@ async function minifyConditionalComments(tree, htmlnanoOptions) {
 /** Minify content inside conditional comments */ const mod = {
     default: minifyConditionalComments
 };
-async function minifycontentInsideConditionalComments(text, htmlnanoOptions) {
-    let match;
+function collectConditionalCommentMatches(text, regexp) {
     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]
-        ]);
+    regexp.lastIndex = 0;
+    let match;
+    while((match = regexp.exec(text)) !== null){
+        matches.push({
+            start: match.index,
+            end: match.index + match[0].length,
+            open: match[1],
+            content: match[2],
+            close: match[3]
+        });
     }
+    return matches;
+}
+function hasHtmlOpeningWithoutClosing(content) {
+    return /<html\b/i.test(content) && !/<\/html>/i.test(content);
+}
+async function minifyContentInsideConditionalComments(text, htmlnanoOptions) {
+    const matches = [
+        ...collectConditionalCommentMatches(text, CONDITIONAL_COMMENT_HIDDEN_REGEXP),
+        ...collectConditionalCommentMatches(text, CONDITIONAL_COMMENT_REVEALED_REGEXP)
+    ].sort((a, b)=>a.start - b.start);
     if (!matches.length) {
         return Promise.resolve(text);
     }
-    return Promise.all(matches.map(async (match)=>{
-        const result = await htmlnano__default.default.process(match[1], htmlnanoOptions, {}, {});
-        let minified = result.html;
-        if (match[1].includes('<html') && minified.includes('</html>')) {
-            minified = minified.replace('</html>', '');
+    let result = '';
+    let lastIndex = 0;
+    for (const match of matches){
+        result += text.slice(lastIndex, match.start);
+        const processed = await htmlnano__default.default.process(match.content, htmlnanoOptions, {}, {});
+        let minified = processed.html;
+        if (hasHtmlOpeningWithoutClosing(match.content) && /<\/html>/i.test(minified)) {
+            minified = minified.replace(/<\/html>/i, '');
         }
-        return match[0] + minified + match[2];
-    }));
+        result += match.open + minified + match.close;
+        lastIndex = match.end;
+    }
+    result += text.slice(lastIndex);
+    return result;
 }
 
 exports.default = mod;

package/dist/_modules/minifyConditionalComments.mjs

@@ -2,14 +2,15 @@ import htmlnano from '../index.mjs';
 import { isConditionalComment } from '../helpers.mjs';
 
 // 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;
+const CONDITIONAL_COMMENT_HIDDEN_REGEXP = /(<!--\[if\s+?[^<>[\]]+?]>)([\s\S]*?)(<!\[endif\]-->)/gm;
+const CONDITIONAL_COMMENT_REVEALED_REGEXP = /(<!--\[if\s+?[^<>[\]]+?\]><!-->)([\s\S]*?)(<!--<!\[endif\]-->)/gm;
 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') {
             if (isConditionalComment(node)) {
-                tree[i] = await minifycontentInsideConditionalComments(node, htmlnanoOptions);
+                tree[i] = await minifyContentInsideConditionalComments(node, htmlnanoOptions);
             }
         } else if (node.content && node.content.length) {
             node.content = await minifyConditionalComments(node.content, htmlnanoOptions);
@@ -20,29 +21,46 @@ async function minifyConditionalComments(tree, htmlnanoOptions) {
 /** Minify content inside conditional comments */ const mod = {
     default: minifyConditionalComments
 };
-async function minifycontentInsideConditionalComments(text, htmlnanoOptions) {
-    let match;
+function collectConditionalCommentMatches(text, regexp) {
     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]
-        ]);
+    regexp.lastIndex = 0;
+    let match;
+    while((match = regexp.exec(text)) !== null){
+        matches.push({
+            start: match.index,
+            end: match.index + match[0].length,
+            open: match[1],
+            content: match[2],
+            close: match[3]
+        });
     }
+    return matches;
+}
+function hasHtmlOpeningWithoutClosing(content) {
+    return /<html\b/i.test(content) && !/<\/html>/i.test(content);
+}
+async function minifyContentInsideConditionalComments(text, htmlnanoOptions) {
+    const matches = [
+        ...collectConditionalCommentMatches(text, CONDITIONAL_COMMENT_HIDDEN_REGEXP),
+        ...collectConditionalCommentMatches(text, CONDITIONAL_COMMENT_REVEALED_REGEXP)
+    ].sort((a, b)=>a.start - b.start);
     if (!matches.length) {
         return Promise.resolve(text);
     }
-    return Promise.all(matches.map(async (match)=>{
-        const result = await htmlnano.process(match[1], htmlnanoOptions, {}, {});
-        let minified = result.html;
-        if (match[1].includes('<html') && minified.includes('</html>')) {
-            minified = minified.replace('</html>', '');
+    let result = '';
+    let lastIndex = 0;
+    for (const match of matches){
+        result += text.slice(lastIndex, match.start);
+        const processed = await htmlnano.process(match.content, htmlnanoOptions, {}, {});
+        let minified = processed.html;
+        if (hasHtmlOpeningWithoutClosing(match.content) && /<\/html>/i.test(minified)) {
+            minified = minified.replace(/<\/html>/i, '');
         }
-        return match[0] + minified + match[2];
-    }));
+        result += match.open + minified + match.close;
+        lastIndex = match.end;
+    }
+    result += text.slice(lastIndex);
+    return result;
 }
 
 export { mod as default };