htmlnano 2.1.2 → 2.1.4

package/dist/_modules/mergeScripts.js

@@ -0,0 +1,53 @@
+Object.defineProperty(exports, '__esModule', { value: true });
+
+var helpers_js = require('../helpers.js');
+
+/* Merge multiple <script> into one */ const mod = {
+    default (tree) {
+        const scriptNodesIndex = {};
+        let scriptSrcIndex = 1;
+        tree.match({
+            tag: 'script'
+        }, (node)=>{
+            const nodeAttrs = node.attrs || {};
+            if ('src' in nodeAttrs || 'integrity' in nodeAttrs) {
+                scriptSrcIndex++;
+                return node;
+            }
+            const scriptType = nodeAttrs.type || 'text/javascript';
+            if (scriptType !== 'text/javascript' && scriptType !== 'application/javascript') {
+                return node;
+            }
+            const 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] = [];
+            }
+            scriptNodesIndex[scriptKey].push(node);
+            return node;
+        });
+        for (const scriptNodes of Object.values(scriptNodesIndex)){
+            const lastScriptNode = scriptNodes.pop();
+            scriptNodes.reverse().forEach((scriptNode)=>{
+                let scriptContent = helpers_js.extractTextContentFromNode(scriptNode).trim();
+                if (scriptContent.slice(-1) !== ';') {
+                    scriptContent += ';';
+                }
+                lastScriptNode.content = lastScriptNode.content || [];
+                lastScriptNode.content.unshift(scriptContent);
+                // @ts-expect-error -- remove node
+                scriptNode.tag = false;
+                scriptNode.content = [];
+            });
+        }
+        return tree;
+    }
+};
+
+exports.default = mod;

package/dist/_modules/mergeScripts.mjs

@@ -0,0 +1,51 @@
+import { extractTextContentFromNode } from '../helpers.mjs';
+
+/* Merge multiple <script> into one */ const mod = {
+    default (tree) {
+        const scriptNodesIndex = {};
+        let scriptSrcIndex = 1;
+        tree.match({
+            tag: 'script'
+        }, (node)=>{
+            const nodeAttrs = node.attrs || {};
+            if ('src' in nodeAttrs || 'integrity' in nodeAttrs) {
+                scriptSrcIndex++;
+                return node;
+            }
+            const scriptType = nodeAttrs.type || 'text/javascript';
+            if (scriptType !== 'text/javascript' && scriptType !== 'application/javascript') {
+                return node;
+            }
+            const 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] = [];
+            }
+            scriptNodesIndex[scriptKey].push(node);
+            return node;
+        });
+        for (const scriptNodes of Object.values(scriptNodesIndex)){
+            const lastScriptNode = scriptNodes.pop();
+            scriptNodes.reverse().forEach((scriptNode)=>{
+                let scriptContent = extractTextContentFromNode(scriptNode).trim();
+                if (scriptContent.slice(-1) !== ';') {
+                    scriptContent += ';';
+                }
+                lastScriptNode.content = lastScriptNode.content || [];
+                lastScriptNode.content.unshift(scriptContent);
+                // @ts-expect-error -- remove node
+                scriptNode.tag = false;
+                scriptNode.content = [];
+            });
+        }
+        return tree;
+    }
+};
+
+export { mod as default };

package/dist/_modules/mergeStyles.d.mts

@@ -0,0 +1,56 @@
+import PostHTML from 'posthtml';
+import { MinifyOptions } from 'terser';
+import { Options } from 'cssnano';
+import { Config } from 'svgo';
+
+type PostHTMLTreeLike = [PostHTML.Node] & PostHTML.NodeAPI & {
+    options?: {
+        quoteAllAttributes?: boolean | undefined;
+    } | undefined;
+    render(): string;
+    render(node: PostHTML.Node | PostHTMLTreeLike, renderOptions?: any): string;
+};
+type MaybeArray<T> = T | Array<T>;
+type PostHTMLNodeLike = PostHTML.Node | string;
+interface HtmlnanoOptions {
+    skipConfigLoading?: boolean;
+    skipInternalWarnings?: boolean;
+    collapseAttributeWhitespace?: boolean;
+    collapseBooleanAttributes?: {
+        amphtml?: boolean;
+    };
+    collapseWhitespace?: 'conservative' | 'all' | 'aggressive';
+    custom?: MaybeArray<(tree: PostHTMLTreeLike, options?: any) => (PostHTML.Node | PostHTMLTreeLike)>;
+    deduplicateAttributeValues?: boolean;
+    minifyUrls?: URL | string | false;
+    mergeStyles?: boolean;
+    mergeScripts?: boolean;
+    minifyCss?: Options | boolean;
+    minifyConditionalComments?: boolean;
+    minifyJs?: MinifyOptions | boolean;
+    minifyJson?: boolean;
+    minifySvg?: Config | boolean;
+    normalizeAttributeValues?: boolean;
+    removeAttributeQuotes?: boolean;
+    removeComments?: boolean | 'safe' | 'all' | RegExp | ((comment: string) => boolean);
+    removeEmptyAttributes?: boolean;
+    removeRedundantAttributes?: boolean;
+    removeOptionalTags?: boolean;
+    removeUnusedCss?: boolean;
+    sortAttributes?: boolean | 'alphabetical' | 'frequency';
+    sortAttributesWithLists?: boolean | 'alphabetical' | 'frequency';
+}
+type HtmlnanoModuleAttrsHandler = (attrs: Record<string, string | boolean | void>, node: PostHTML.Node) => Record<string, string | boolean | void>;
+type HtmlnanoModuleContentHandler = (content: Array<PostHTMLNodeLike>, node: PostHTML.Node) => MaybeArray<PostHTMLNodeLike>;
+type HtmlnanoModuleNodeHandler = (node: PostHTMLNodeLike) => PostHTML.Node | string;
+type OptionalOptions<T> = T extends boolean | string | Function | number | null | undefined ? T : T extends object ? Partial<T> : T;
+type HtmlnanoModule<Options = any> = {
+    onAttrs?: (options: Partial<HtmlnanoOptions>, moduleOptions: OptionalOptions<Options>) => HtmlnanoModuleAttrsHandler;
+    onContent?: (options: Partial<HtmlnanoOptions>, moduleOptions: OptionalOptions<Options>) => HtmlnanoModuleContentHandler;
+    onNode?: (options: Partial<HtmlnanoOptions>, moduleOptions: OptionalOptions<Options>) => HtmlnanoModuleNodeHandler;
+    default?: (tree: PostHTMLTreeLike, options: Partial<HtmlnanoOptions>, moduleOptions: OptionalOptions<Options>) => PostHTMLTreeLike | Promise<PostHTMLTreeLike>;
+};
+
+declare const mod: HtmlnanoModule;
+
+export { mod as default };

package/dist/_modules/mergeStyles.d.ts

@@ -0,0 +1,56 @@
+import PostHTML from 'posthtml';
+import { MinifyOptions } from 'terser';
+import { Options } from 'cssnano';
+import { Config } from 'svgo';
+
+type PostHTMLTreeLike = [PostHTML.Node] & PostHTML.NodeAPI & {
+    options?: {
+        quoteAllAttributes?: boolean | undefined;
+    } | undefined;
+    render(): string;
+    render(node: PostHTML.Node | PostHTMLTreeLike, renderOptions?: any): string;
+};
+type MaybeArray<T> = T | Array<T>;
+type PostHTMLNodeLike = PostHTML.Node | string;
+interface HtmlnanoOptions {
+    skipConfigLoading?: boolean;
+    skipInternalWarnings?: boolean;
+    collapseAttributeWhitespace?: boolean;
+    collapseBooleanAttributes?: {
+        amphtml?: boolean;
+    };
+    collapseWhitespace?: 'conservative' | 'all' | 'aggressive';
+    custom?: MaybeArray<(tree: PostHTMLTreeLike, options?: any) => (PostHTML.Node | PostHTMLTreeLike)>;
+    deduplicateAttributeValues?: boolean;
+    minifyUrls?: URL | string | false;
+    mergeStyles?: boolean;
+    mergeScripts?: boolean;
+    minifyCss?: Options | boolean;
+    minifyConditionalComments?: boolean;
+    minifyJs?: MinifyOptions | boolean;
+    minifyJson?: boolean;
+    minifySvg?: Config | boolean;
+    normalizeAttributeValues?: boolean;
+    removeAttributeQuotes?: boolean;
+    removeComments?: boolean | 'safe' | 'all' | RegExp | ((comment: string) => boolean);
+    removeEmptyAttributes?: boolean;
+    removeRedundantAttributes?: boolean;
+    removeOptionalTags?: boolean;
+    removeUnusedCss?: boolean;
+    sortAttributes?: boolean | 'alphabetical' | 'frequency';
+    sortAttributesWithLists?: boolean | 'alphabetical' | 'frequency';
+}
+type HtmlnanoModuleAttrsHandler = (attrs: Record<string, string | boolean | void>, node: PostHTML.Node) => Record<string, string | boolean | void>;
+type HtmlnanoModuleContentHandler = (content: Array<PostHTMLNodeLike>, node: PostHTML.Node) => MaybeArray<PostHTMLNodeLike>;
+type HtmlnanoModuleNodeHandler = (node: PostHTMLNodeLike) => PostHTML.Node | string;
+type OptionalOptions<T> = T extends boolean | string | Function | number | null | undefined ? T : T extends object ? Partial<T> : T;
+type HtmlnanoModule<Options = any> = {
+    onAttrs?: (options: Partial<HtmlnanoOptions>, moduleOptions: OptionalOptions<Options>) => HtmlnanoModuleAttrsHandler;
+    onContent?: (options: Partial<HtmlnanoOptions>, moduleOptions: OptionalOptions<Options>) => HtmlnanoModuleContentHandler;
+    onNode?: (options: Partial<HtmlnanoOptions>, moduleOptions: OptionalOptions<Options>) => HtmlnanoModuleNodeHandler;
+    default?: (tree: PostHTMLTreeLike, options: Partial<HtmlnanoOptions>, moduleOptions: OptionalOptions<Options>) => PostHTMLTreeLike | Promise<PostHTMLTreeLike>;
+};
+
+declare const mod: HtmlnanoModule;
+
+export { mod as default };

package/dist/_modules/mergeStyles.js

@@ -0,0 +1,42 @@
+Object.defineProperty(exports, '__esModule', { value: true });
+
+var helpers_js = require('../helpers.js');
+
+/* Merge multiple <style> into one */ const mod = {
+    default (tree) {
+        const styleNodes = {};
+        tree.match({
+            tag: 'style'
+        }, (node)=>{
+            if (typeof node !== 'object' || !node.tag || !node.content) return node;
+            const nodeAttrs = node.attrs || {};
+            // Skip <style scoped></style>
+            // https://developer.mozilla.org/en/docs/Web/HTML/Element/style
+            //
+            // Also skip SRI, reasons are documented in "minifyJs" module
+            if ('scoped' in nodeAttrs || 'integrity' in nodeAttrs) {
+                return node;
+            }
+            if (helpers_js.isAmpBoilerplate(node)) {
+                return node;
+            }
+            const styleType = nodeAttrs.type || 'text/css';
+            const styleMedia = nodeAttrs.media || 'all';
+            const styleKey = styleType + '_' + styleMedia;
+            if (styleKey in styleNodes) {
+                var _styleNodes_styleKey;
+                const styleContent = helpers_js.extractTextContentFromNode(node);
+                var _content;
+                (_content = (_styleNodes_styleKey = styleNodes[styleKey]).content) != null ? _content : _styleNodes_styleKey.content = [];
+                styleNodes[styleKey].content.push(' ' + styleContent);
+                return ''; // Remove node
+            }
+            node.content = node.content || [];
+            styleNodes[styleKey] = node;
+            return node;
+        });
+        return tree;
+    }
+};
+
+exports.default = mod;

package/dist/_modules/mergeStyles.mjs

@@ -0,0 +1,40 @@
+import { isAmpBoilerplate, extractTextContentFromNode } from '../helpers.mjs';
+
+/* Merge multiple <style> into one */ const mod = {
+    default (tree) {
+        const styleNodes = {};
+        tree.match({
+            tag: 'style'
+        }, (node)=>{
+            if (typeof node !== 'object' || !node.tag || !node.content) return node;
+            const nodeAttrs = node.attrs || {};
+            // Skip <style scoped></style>
+            // https://developer.mozilla.org/en/docs/Web/HTML/Element/style
+            //
+            // Also skip SRI, reasons are documented in "minifyJs" module
+            if ('scoped' in nodeAttrs || 'integrity' in nodeAttrs) {
+                return node;
+            }
+            if (isAmpBoilerplate(node)) {
+                return node;
+            }
+            const styleType = nodeAttrs.type || 'text/css';
+            const styleMedia = nodeAttrs.media || 'all';
+            const styleKey = styleType + '_' + styleMedia;
+            if (styleKey in styleNodes) {
+                var _styleNodes_styleKey;
+                const styleContent = extractTextContentFromNode(node);
+                var _content;
+                (_content = (_styleNodes_styleKey = styleNodes[styleKey]).content) != null ? _content : _styleNodes_styleKey.content = [];
+                styleNodes[styleKey].content.push(' ' + styleContent);
+                return ''; // Remove node
+            }
+            node.content = node.content || [];
+            styleNodes[styleKey] = node;
+            return node;
+        });
+        return tree;
+    }
+};
+
+export { mod as default };

package/dist/_modules/minifyConditionalComments.d.mts

@@ -0,0 +1,56 @@
+import PostHTML from 'posthtml';
+import { MinifyOptions } from 'terser';
+import { Options } from 'cssnano';
+import { Config } from 'svgo';
+
+type PostHTMLTreeLike = [PostHTML.Node] & PostHTML.NodeAPI & {
+    options?: {
+        quoteAllAttributes?: boolean | undefined;
+    } | undefined;
+    render(): string;
+    render(node: PostHTML.Node | PostHTMLTreeLike, renderOptions?: any): string;
+};
+type MaybeArray<T> = T | Array<T>;
+type PostHTMLNodeLike = PostHTML.Node | string;
+interface HtmlnanoOptions {
+    skipConfigLoading?: boolean;
+    skipInternalWarnings?: boolean;
+    collapseAttributeWhitespace?: boolean;
+    collapseBooleanAttributes?: {
+        amphtml?: boolean;
+    };
+    collapseWhitespace?: 'conservative' | 'all' | 'aggressive';
+    custom?: MaybeArray<(tree: PostHTMLTreeLike, options?: any) => (PostHTML.Node | PostHTMLTreeLike)>;
+    deduplicateAttributeValues?: boolean;
+    minifyUrls?: URL | string | false;
+    mergeStyles?: boolean;
+    mergeScripts?: boolean;
+    minifyCss?: Options | boolean;
+    minifyConditionalComments?: boolean;
+    minifyJs?: MinifyOptions | boolean;
+    minifyJson?: boolean;
+    minifySvg?: Config | boolean;
+    normalizeAttributeValues?: boolean;
+    removeAttributeQuotes?: boolean;
+    removeComments?: boolean | 'safe' | 'all' | RegExp | ((comment: string) => boolean);
+    removeEmptyAttributes?: boolean;
+    removeRedundantAttributes?: boolean;
+    removeOptionalTags?: boolean;
+    removeUnusedCss?: boolean;
+    sortAttributes?: boolean | 'alphabetical' | 'frequency';
+    sortAttributesWithLists?: boolean | 'alphabetical' | 'frequency';
+}
+type HtmlnanoModuleAttrsHandler = (attrs: Record<string, string | boolean | void>, node: PostHTML.Node) => Record<string, string | boolean | void>;
+type HtmlnanoModuleContentHandler = (content: Array<PostHTMLNodeLike>, node: PostHTML.Node) => MaybeArray<PostHTMLNodeLike>;
+type HtmlnanoModuleNodeHandler = (node: PostHTMLNodeLike) => PostHTML.Node | string;
+type OptionalOptions<T> = T extends boolean | string | Function | number | null | undefined ? T : T extends object ? Partial<T> : T;
+type HtmlnanoModule<Options = any> = {
+    onAttrs?: (options: Partial<HtmlnanoOptions>, moduleOptions: OptionalOptions<Options>) => HtmlnanoModuleAttrsHandler;
+    onContent?: (options: Partial<HtmlnanoOptions>, moduleOptions: OptionalOptions<Options>) => HtmlnanoModuleContentHandler;
+    onNode?: (options: Partial<HtmlnanoOptions>, moduleOptions: OptionalOptions<Options>) => HtmlnanoModuleNodeHandler;
+    default?: (tree: PostHTMLTreeLike, options: Partial<HtmlnanoOptions>, moduleOptions: OptionalOptions<Options>) => PostHTMLTreeLike | Promise<PostHTMLTreeLike>;
+};
+
+declare const mod: HtmlnanoModule;
+
+export { mod as default };

package/dist/_modules/minifyConditionalComments.d.ts

@@ -0,0 +1,56 @@
+import PostHTML from 'posthtml';
+import { MinifyOptions } from 'terser';
+import { Options } from 'cssnano';
+import { Config } from 'svgo';
+
+type PostHTMLTreeLike = [PostHTML.Node] & PostHTML.NodeAPI & {
+    options?: {
+        quoteAllAttributes?: boolean | undefined;
+    } | undefined;
+    render(): string;
+    render(node: PostHTML.Node | PostHTMLTreeLike, renderOptions?: any): string;
+};
+type MaybeArray<T> = T | Array<T>;
+type PostHTMLNodeLike = PostHTML.Node | string;
+interface HtmlnanoOptions {
+    skipConfigLoading?: boolean;
+    skipInternalWarnings?: boolean;
+    collapseAttributeWhitespace?: boolean;
+    collapseBooleanAttributes?: {
+        amphtml?: boolean;
+    };
+    collapseWhitespace?: 'conservative' | 'all' | 'aggressive';
+    custom?: MaybeArray<(tree: PostHTMLTreeLike, options?: any) => (PostHTML.Node | PostHTMLTreeLike)>;
+    deduplicateAttributeValues?: boolean;
+    minifyUrls?: URL | string | false;
+    mergeStyles?: boolean;
+    mergeScripts?: boolean;
+    minifyCss?: Options | boolean;
+    minifyConditionalComments?: boolean;
+    minifyJs?: MinifyOptions | boolean;
+    minifyJson?: boolean;
+    minifySvg?: Config | boolean;
+    normalizeAttributeValues?: boolean;
+    removeAttributeQuotes?: boolean;
+    removeComments?: boolean | 'safe' | 'all' | RegExp | ((comment: string) => boolean);
+    removeEmptyAttributes?: boolean;
+    removeRedundantAttributes?: boolean;
+    removeOptionalTags?: boolean;
+    removeUnusedCss?: boolean;
+    sortAttributes?: boolean | 'alphabetical' | 'frequency';
+    sortAttributesWithLists?: boolean | 'alphabetical' | 'frequency';
+}
+type HtmlnanoModuleAttrsHandler = (attrs: Record<string, string | boolean | void>, node: PostHTML.Node) => Record<string, string | boolean | void>;
+type HtmlnanoModuleContentHandler = (content: Array<PostHTMLNodeLike>, node: PostHTML.Node) => MaybeArray<PostHTMLNodeLike>;
+type HtmlnanoModuleNodeHandler = (node: PostHTMLNodeLike) => PostHTML.Node | string;
+type OptionalOptions<T> = T extends boolean | string | Function | number | null | undefined ? T : T extends object ? Partial<T> : T;
+type HtmlnanoModule<Options = any> = {
+    onAttrs?: (options: Partial<HtmlnanoOptions>, moduleOptions: OptionalOptions<Options>) => HtmlnanoModuleAttrsHandler;
+    onContent?: (options: Partial<HtmlnanoOptions>, moduleOptions: OptionalOptions<Options>) => HtmlnanoModuleContentHandler;
+    onNode?: (options: Partial<HtmlnanoOptions>, moduleOptions: OptionalOptions<Options>) => HtmlnanoModuleNodeHandler;
+    default?: (tree: PostHTMLTreeLike, options: Partial<HtmlnanoOptions>, moduleOptions: OptionalOptions<Options>) => PostHTMLTreeLike | Promise<PostHTMLTreeLike>;
+};
+
+declare const mod: HtmlnanoModule;
+
+export { mod as default };

package/dist/_modules/minifyConditionalComments.js

@@ -0,0 +1,54 @@
+Object.defineProperty(exports, '__esModule', { value: true });
+
+var htmlnano = require('../index.js');
+var helpers_js = require('../helpers.js');
+
+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;
+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);
+            }
+        } else if (node.content && node.content.length) {
+            node.content = await minifyConditionalComments(node.content, htmlnanoOptions);
+        }
+    }
+    return tree;
+}
+/** Minify content inside conditional comments */ const mod = {
+    default: minifyConditionalComments
+};
+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.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];
+    }));
+}
+
+exports.default = mod;

package/{lib/modules → dist/_modules}/minifyConditionalComments.mjs

@@ -1,49 +1,48 @@
-import htmlnano from '../htmlnano.mjs';
+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;
-
-/** Minify content inside conditional comments */
-export default async function minifyConditionalComments(tree, htmlnanoOptions) {
+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++) {
+    for(let i = 0, len = tree.length; i < len; i++){
         const node = tree[i];
-
-        if (typeof node === 'string' && isConditionalComment(node)) {
-            tree[i] = await minifycontentInsideConditionalComments(node, htmlnanoOptions);
-        }
-
-        if (node.content && node.content.length) {
-            tree[i].content = await minifyConditionalComments(node.content, htmlnanoOptions);
+        if (typeof node === 'string') {
+            if (isConditionalComment(node)) {
+                tree[i] = await minifycontentInsideConditionalComments(node, htmlnanoOptions);
+            }
+        } else if (node.content && node.content.length) {
+            node.content = await minifyConditionalComments(node.content, htmlnanoOptions);
         }
     }
-
     return tree;
 }
-
+/** Minify content inside conditional comments */ const mod = {
+    default: minifyConditionalComments
+};
 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]]);
+    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 => {
+    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>', '');
         }
-
         return match[0] + minified + match[2];
     }));
 }
+
+export { mod as default };

package/dist/_modules/minifyCss.d.mts

@@ -0,0 +1,56 @@
+import PostHTML from 'posthtml';
+import { MinifyOptions } from 'terser';
+import { Options } from 'cssnano';
+import { Config } from 'svgo';
+
+type PostHTMLTreeLike = [PostHTML.Node] & PostHTML.NodeAPI & {
+    options?: {
+        quoteAllAttributes?: boolean | undefined;
+    } | undefined;
+    render(): string;
+    render(node: PostHTML.Node | PostHTMLTreeLike, renderOptions?: any): string;
+};
+type MaybeArray<T> = T | Array<T>;
+type PostHTMLNodeLike = PostHTML.Node | string;
+interface HtmlnanoOptions {
+    skipConfigLoading?: boolean;
+    skipInternalWarnings?: boolean;
+    collapseAttributeWhitespace?: boolean;
+    collapseBooleanAttributes?: {
+        amphtml?: boolean;
+    };
+    collapseWhitespace?: 'conservative' | 'all' | 'aggressive';
+    custom?: MaybeArray<(tree: PostHTMLTreeLike, options?: any) => (PostHTML.Node | PostHTMLTreeLike)>;
+    deduplicateAttributeValues?: boolean;
+    minifyUrls?: URL | string | false;
+    mergeStyles?: boolean;
+    mergeScripts?: boolean;
+    minifyCss?: Options | boolean;
+    minifyConditionalComments?: boolean;
+    minifyJs?: MinifyOptions | boolean;
+    minifyJson?: boolean;
+    minifySvg?: Config | boolean;
+    normalizeAttributeValues?: boolean;
+    removeAttributeQuotes?: boolean;
+    removeComments?: boolean | 'safe' | 'all' | RegExp | ((comment: string) => boolean);
+    removeEmptyAttributes?: boolean;
+    removeRedundantAttributes?: boolean;
+    removeOptionalTags?: boolean;
+    removeUnusedCss?: boolean;
+    sortAttributes?: boolean | 'alphabetical' | 'frequency';
+    sortAttributesWithLists?: boolean | 'alphabetical' | 'frequency';
+}
+type HtmlnanoModuleAttrsHandler = (attrs: Record<string, string | boolean | void>, node: PostHTML.Node) => Record<string, string | boolean | void>;
+type HtmlnanoModuleContentHandler = (content: Array<PostHTMLNodeLike>, node: PostHTML.Node) => MaybeArray<PostHTMLNodeLike>;
+type HtmlnanoModuleNodeHandler = (node: PostHTMLNodeLike) => PostHTML.Node | string;
+type OptionalOptions<T> = T extends boolean | string | Function | number | null | undefined ? T : T extends object ? Partial<T> : T;
+type HtmlnanoModule<Options = any> = {
+    onAttrs?: (options: Partial<HtmlnanoOptions>, moduleOptions: OptionalOptions<Options>) => HtmlnanoModuleAttrsHandler;
+    onContent?: (options: Partial<HtmlnanoOptions>, moduleOptions: OptionalOptions<Options>) => HtmlnanoModuleContentHandler;
+    onNode?: (options: Partial<HtmlnanoOptions>, moduleOptions: OptionalOptions<Options>) => HtmlnanoModuleNodeHandler;
+    default?: (tree: PostHTMLTreeLike, options: Partial<HtmlnanoOptions>, moduleOptions: OptionalOptions<Options>) => PostHTMLTreeLike | Promise<PostHTMLTreeLike>;
+};
+
+declare const mod: HtmlnanoModule<Options>;
+
+export { mod as default };

package/dist/_modules/minifyCss.d.ts

@@ -0,0 +1,56 @@
+import PostHTML from 'posthtml';
+import { MinifyOptions } from 'terser';
+import { Options } from 'cssnano';
+import { Config } from 'svgo';
+
+type PostHTMLTreeLike = [PostHTML.Node] & PostHTML.NodeAPI & {
+    options?: {
+        quoteAllAttributes?: boolean | undefined;
+    } | undefined;
+    render(): string;
+    render(node: PostHTML.Node | PostHTMLTreeLike, renderOptions?: any): string;
+};
+type MaybeArray<T> = T | Array<T>;
+type PostHTMLNodeLike = PostHTML.Node | string;
+interface HtmlnanoOptions {
+    skipConfigLoading?: boolean;
+    skipInternalWarnings?: boolean;
+    collapseAttributeWhitespace?: boolean;
+    collapseBooleanAttributes?: {
+        amphtml?: boolean;
+    };
+    collapseWhitespace?: 'conservative' | 'all' | 'aggressive';
+    custom?: MaybeArray<(tree: PostHTMLTreeLike, options?: any) => (PostHTML.Node | PostHTMLTreeLike)>;
+    deduplicateAttributeValues?: boolean;
+    minifyUrls?: URL | string | false;
+    mergeStyles?: boolean;
+    mergeScripts?: boolean;
+    minifyCss?: Options | boolean;
+    minifyConditionalComments?: boolean;
+    minifyJs?: MinifyOptions | boolean;
+    minifyJson?: boolean;
+    minifySvg?: Config | boolean;
+    normalizeAttributeValues?: boolean;
+    removeAttributeQuotes?: boolean;
+    removeComments?: boolean | 'safe' | 'all' | RegExp | ((comment: string) => boolean);
+    removeEmptyAttributes?: boolean;
+    removeRedundantAttributes?: boolean;
+    removeOptionalTags?: boolean;
+    removeUnusedCss?: boolean;
+    sortAttributes?: boolean | 'alphabetical' | 'frequency';
+    sortAttributesWithLists?: boolean | 'alphabetical' | 'frequency';
+}
+type HtmlnanoModuleAttrsHandler = (attrs: Record<string, string | boolean | void>, node: PostHTML.Node) => Record<string, string | boolean | void>;
+type HtmlnanoModuleContentHandler = (content: Array<PostHTMLNodeLike>, node: PostHTML.Node) => MaybeArray<PostHTMLNodeLike>;
+type HtmlnanoModuleNodeHandler = (node: PostHTMLNodeLike) => PostHTML.Node | string;
+type OptionalOptions<T> = T extends boolean | string | Function | number | null | undefined ? T : T extends object ? Partial<T> : T;
+type HtmlnanoModule<Options = any> = {
+    onAttrs?: (options: Partial<HtmlnanoOptions>, moduleOptions: OptionalOptions<Options>) => HtmlnanoModuleAttrsHandler;
+    onContent?: (options: Partial<HtmlnanoOptions>, moduleOptions: OptionalOptions<Options>) => HtmlnanoModuleContentHandler;
+    onNode?: (options: Partial<HtmlnanoOptions>, moduleOptions: OptionalOptions<Options>) => HtmlnanoModuleNodeHandler;
+    default?: (tree: PostHTMLTreeLike, options: Partial<HtmlnanoOptions>, moduleOptions: OptionalOptions<Options>) => PostHTMLTreeLike | Promise<PostHTMLTreeLike>;
+};
+
+declare const mod: HtmlnanoModule<Options>;
+
+export { mod as default };