htmlnano 3.0.0 → 3.2.0

package/dist/_modules/mergeScripts.mjs

@@ -1,49 +1,136 @@
 import { extractTextContentFromNode } from '../helpers.mjs';
 
+function normalizeAttrsForKey(attrs, config) {
+    const normalized = {
+        ...config.baseAttrs
+    };
+    for (const [key, value] of Object.entries(attrs || {})){
+        if (config.skippedAttrs.has(key) || value === undefined) {
+            continue;
+        }
+        if (config.booleanAttrs.has(key)) {
+            normalized[key] = true;
+            continue;
+        }
+        normalized[key] = value;
+    }
+    return normalized;
+}
+
+function normalizeAsyncAttr(attrs) {
+    if (!attrs) {
+        return;
+    }
+    if (attrs.async === '') {
+        attrs.async = true;
+    }
+    if (attrs.nomodule === '') {
+        attrs.nomodule = true;
+    }
+}
+function getScriptType(attrs) {
+    const type = attrs.type || 'text/javascript';
+    return typeof type === 'string' ? type.toLowerCase() : 'text/javascript';
+}
+function isMergeableScriptType(type) {
+    return type === 'text/javascript' || type === 'application/javascript';
+}
+const booleanAttrs = new Set([
+    'async',
+    'defer',
+    'nomodule'
+]);
+const skippedAttrs = new Set([
+    'src',
+    'integrity',
+    'type'
+]);
+function normalizeScriptAttrsForKey(attrs, scriptType) {
+    return normalizeAttrsForKey(attrs, {
+        baseAttrs: {
+            type: scriptType
+        },
+        booleanAttrs,
+        skippedAttrs
+    });
+}
+function buildScriptKey(attrs, scriptType, scriptSrcIndex) {
+    const normalizedAttrs = normalizeScriptAttrsForKey(attrs, scriptType);
+    const keyObject = {
+        index: scriptSrcIndex,
+        ...normalizedAttrs
+    };
+    const sortedKeys = Object.keys(keyObject).sort();
+    const sortedKeyObject = {};
+    for (const key of sortedKeys){
+        sortedKeyObject[key] = keyObject[key];
+    }
+    return JSON.stringify(sortedKeyObject);
+}
+function endsWithLineComment(scriptContent) {
+    const lastNewlineIndex = Math.max(scriptContent.lastIndexOf('\n'), scriptContent.lastIndexOf('\r'));
+    const lastLine = lastNewlineIndex === -1 ? scriptContent : scriptContent.slice(lastNewlineIndex + 1);
+    return /\/\/.*$/.test(lastLine);
+}
+function mergeScriptNodes(scriptNodesIndex, tracking) {
+    for (const scriptNodes of Object.values(scriptNodesIndex)){
+        if (scriptNodes.length < 2) {
+            continue;
+        }
+        const lastScriptNode = scriptNodes.pop();
+        tracking.mergedScriptNodes.add(lastScriptNode);
+        scriptNodes.reverse().forEach((scriptNode)=>{
+            let scriptContent = extractTextContentFromNode(scriptNode).trim();
+            if (!scriptContent) {
+                tracking.removedScriptNodes.add(scriptNode);
+                // @ts-expect-error -- remove node
+                scriptNode.tag = false;
+                scriptNode.content = [];
+                return;
+            }
+            if (endsWithLineComment(scriptContent)) {
+                scriptContent += '\n;';
+            } else if (scriptContent.slice(-1) !== ';') {
+                scriptContent += ';';
+            }
+            lastScriptNode.content = lastScriptNode.content || [];
+            lastScriptNode.content.unshift(scriptContent);
+            tracking.removedScriptNodes.add(scriptNode);
+            // @ts-expect-error -- remove node
+            scriptNode.tag = false;
+            scriptNode.content = [];
+        });
+    }
+}
 /* Merge multiple <script> into one */ const mod = {
     default (tree) {
         const scriptNodesIndex = {};
+        const tracking = {
+            mergedScriptNodes: new WeakSet(),
+            removedScriptNodes: new WeakSet()
+        };
         let scriptSrcIndex = 1;
         tree.match({
             tag: 'script'
         }, (node)=>{
             const nodeAttrs = node.attrs || {};
+            normalizeAsyncAttr(nodeAttrs);
             if ('src' in nodeAttrs || 'integrity' in nodeAttrs) {
                 scriptSrcIndex++;
                 return node;
             }
-            const scriptType = nodeAttrs.type || 'text/javascript';
-            if (scriptType !== 'text/javascript' && scriptType !== 'application/javascript') {
+            const scriptType = getScriptType(nodeAttrs);
+            if (!isMergeableScriptType(scriptType)) {
                 return node;
             }
-            const scriptKey = JSON.stringify({
-                id: nodeAttrs.id,
-                class: nodeAttrs.class,
-                type: scriptType,
-                defer: nodeAttrs.defer !== undefined,
-                async: nodeAttrs.async !== undefined,
-                index: scriptSrcIndex
-            });
+            const scriptKey = buildScriptKey(nodeAttrs, scriptType, 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 = [];
-            });
-        }
+        mergeScriptNodes(scriptNodesIndex, tracking);
         return tree;
     }
 };

package/dist/_modules/mergeStyles.d.mts

@@ -2,16 +2,24 @@ 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;
@@ -27,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/mergeStyles.d.ts

@@ -2,16 +2,24 @@ 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;
@@ -27,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/mergeStyles.js

@@ -2,6 +2,70 @@ Object.defineProperty(exports, '__esModule', { value: true });
 
 var helpers_js = require('../helpers.js');
 
+function normalizeAttrsForKey(attrs, config) {
+    const normalized = {
+        ...config.baseAttrs
+    };
+    for (const [key, value] of Object.entries(attrs || {})){
+        if (config.skippedAttrs.has(key) || value === undefined) {
+            continue;
+        }
+        if (config.booleanAttrs.has(key)) {
+            normalized[key] = true;
+            continue;
+        }
+        normalized[key] = value;
+    }
+    return normalized;
+}
+
+const booleanAttrs = new Set([
+    'amp-custom',
+    'disabled'
+]);
+const skippedAttrs = new Set([
+    'type',
+    'media'
+]);
+function normalizeStyleType(attrs) {
+    if (!attrs || typeof attrs.type !== 'string') {
+        return 'text/css';
+    }
+    const type = attrs.type.trim();
+    return type ? type.toLowerCase() : 'text/css';
+}
+function normalizeStyleMedia(attrs) {
+    if (!attrs || typeof attrs.media !== 'string') {
+        return 'all';
+    }
+    const media = attrs.media.trim();
+    return media ? media.replace(/\s+/g, ' ').toLowerCase() : 'all';
+}
+function normalizeStyleAttrsForKey(attrs) {
+    return normalizeAttrsForKey(attrs, {
+        booleanAttrs,
+        skippedAttrs
+    });
+}
+function buildStyleKey(attrs) {
+    const keyObject = {
+        type: normalizeStyleType(attrs),
+        media: normalizeStyleMedia(attrs),
+        ...normalizeStyleAttrsForKey(attrs)
+    };
+    const sortedKeys = Object.keys(keyObject).sort();
+    const sortedKeyObject = {};
+    for (const key of sortedKeys){
+        sortedKeyObject[key] = keyObject[key];
+    }
+    return JSON.stringify(sortedKeyObject);
+}
+function extractStyleTextContent(node) {
+    if (typeof node.content === 'string') {
+        return node.content;
+    }
+    return helpers_js.extractTextContentFromNode(node);
+}
 /* Merge multiple <style> into one */ const mod = {
     default (tree) {
         const styleNodes = {};
@@ -20,12 +84,10 @@ var helpers_js = require('../helpers.js');
             if (helpers_js.isAmpBoilerplate(node)) {
                 return node;
             }
-            const styleType = nodeAttrs.type || 'text/css';
-            const styleMedia = nodeAttrs.media || 'all';
-            const styleKey = styleType + '_' + styleMedia;
+            const styleKey = buildStyleKey(nodeAttrs);
             if (styleKey in styleNodes) {
                 var _styleNodes_styleKey, _content;
-                const styleContent = helpers_js.extractTextContentFromNode(node);
+                const styleContent = extractStyleTextContent(node);
                 (_content = (_styleNodes_styleKey = styleNodes[styleKey]).content) != null ? _content : _styleNodes_styleKey.content = [];
                 styleNodes[styleKey].content.push(' ' + styleContent);
                 return ''; // Remove node

package/dist/_modules/mergeStyles.mjs

@@ -1,5 +1,69 @@
 import { isAmpBoilerplate, extractTextContentFromNode } from '../helpers.mjs';
 
+function normalizeAttrsForKey(attrs, config) {
+    const normalized = {
+        ...config.baseAttrs
+    };
+    for (const [key, value] of Object.entries(attrs || {})){
+        if (config.skippedAttrs.has(key) || value === undefined) {
+            continue;
+        }
+        if (config.booleanAttrs.has(key)) {
+            normalized[key] = true;
+            continue;
+        }
+        normalized[key] = value;
+    }
+    return normalized;
+}
+
+const booleanAttrs = new Set([
+    'amp-custom',
+    'disabled'
+]);
+const skippedAttrs = new Set([
+    'type',
+    'media'
+]);
+function normalizeStyleType(attrs) {
+    if (!attrs || typeof attrs.type !== 'string') {
+        return 'text/css';
+    }
+    const type = attrs.type.trim();
+    return type ? type.toLowerCase() : 'text/css';
+}
+function normalizeStyleMedia(attrs) {
+    if (!attrs || typeof attrs.media !== 'string') {
+        return 'all';
+    }
+    const media = attrs.media.trim();
+    return media ? media.replace(/\s+/g, ' ').toLowerCase() : 'all';
+}
+function normalizeStyleAttrsForKey(attrs) {
+    return normalizeAttrsForKey(attrs, {
+        booleanAttrs,
+        skippedAttrs
+    });
+}
+function buildStyleKey(attrs) {
+    const keyObject = {
+        type: normalizeStyleType(attrs),
+        media: normalizeStyleMedia(attrs),
+        ...normalizeStyleAttrsForKey(attrs)
+    };
+    const sortedKeys = Object.keys(keyObject).sort();
+    const sortedKeyObject = {};
+    for (const key of sortedKeys){
+        sortedKeyObject[key] = keyObject[key];
+    }
+    return JSON.stringify(sortedKeyObject);
+}
+function extractStyleTextContent(node) {
+    if (typeof node.content === 'string') {
+        return node.content;
+    }
+    return extractTextContentFromNode(node);
+}
 /* Merge multiple <style> into one */ const mod = {
     default (tree) {
         const styleNodes = {};
@@ -18,12 +82,10 @@ import { isAmpBoilerplate, extractTextContentFromNode } from '../helpers.mjs';
             if (isAmpBoilerplate(node)) {
                 return node;
             }
-            const styleType = nodeAttrs.type || 'text/css';
-            const styleMedia = nodeAttrs.media || 'all';
-            const styleKey = styleType + '_' + styleMedia;
+            const styleKey = buildStyleKey(nodeAttrs);
             if (styleKey in styleNodes) {
                 var _styleNodes_styleKey, _content;
-                const styleContent = extractTextContentFromNode(node);
+                const styleContent = extractStyleTextContent(node);
                 (_content = (_styleNodes_styleKey = styleNodes[styleKey]).content) != null ? _content : _styleNodes_styleKey.content = [];
                 styleNodes[styleKey].content.push(' ' + styleContent);
                 return ''; // Remove node

package/dist/_modules/minifyAttributes.d.mts

@@ -0,0 +1,95 @@
+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?: {
+        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;
+    minifyHtmlTemplate?: MinifyHtmlTemplateOptions;
+    minifyConditionalComments?: boolean;
+    minifyJs?: MinifyOptions | boolean;
+    minifyJson?: boolean;
+    minifyAttributes?: boolean | {
+        metaContent?: boolean;
+        redundantWhitespaces?: 'safe' | 'agressive' | false;
+    };
+    minifySvg?: Config | boolean;
+    normalizeAttributeValues?: boolean;
+    removeAttributeQuotes?: boolean | {
+        force?: boolean;
+    };
+    removeComments?: boolean | RegExp | ((comment: string) => boolean) | string;
+    removeEmptyAttributes?: boolean;
+    removeEmptyElements?: boolean | {
+        removeWithAttributes?: boolean;
+    };
+    removeRedundantAttributes?: boolean;
+    removeOptionalTags?: 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';
+}
+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>;
+};
+
+type RedundantWhitespaceMode = 'safe' | 'agressive' | false;
+type MinifyAttributesOptions = {
+    metaContent?: boolean;
+    redundantWhitespaces?: RedundantWhitespaceMode | 'aggressive';
+};
+declare const mod: HtmlnanoModule<MinifyAttributesOptions>;
+
+export { mod as default };

package/dist/_modules/minifyAttributes.d.ts

@@ -0,0 +1,95 @@
+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?: {
+        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;
+    minifyHtmlTemplate?: MinifyHtmlTemplateOptions;
+    minifyConditionalComments?: boolean;
+    minifyJs?: MinifyOptions | boolean;
+    minifyJson?: boolean;
+    minifyAttributes?: boolean | {
+        metaContent?: boolean;
+        redundantWhitespaces?: 'safe' | 'agressive' | false;
+    };
+    minifySvg?: Config | boolean;
+    normalizeAttributeValues?: boolean;
+    removeAttributeQuotes?: boolean | {
+        force?: boolean;
+    };
+    removeComments?: boolean | RegExp | ((comment: string) => boolean) | string;
+    removeEmptyAttributes?: boolean;
+    removeEmptyElements?: boolean | {
+        removeWithAttributes?: boolean;
+    };
+    removeRedundantAttributes?: boolean;
+    removeOptionalTags?: 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';
+}
+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>;
+};
+
+type RedundantWhitespaceMode = 'safe' | 'agressive' | false;
+type MinifyAttributesOptions = {
+    metaContent?: boolean;
+    redundantWhitespaces?: RedundantWhitespaceMode | 'aggressive';
+};
+declare const mod: HtmlnanoModule<MinifyAttributesOptions>;
+
+export { mod as default };