htmlnano 3.0.0 → 3.2.0

package/dist/_modules/sortAttributesWithLists.mjs

@@ -1,52 +1,68 @@
-import { attributesWithLists } from './collapseAttributeWhitespace.mjs';
+import { isListAttribute } from './collapseAttributeWhitespace.mjs';
 
-// class, rel, ping
 const validOptions = new Set([
     'frequency',
     'alphabetical'
 ]);
-const processModuleOptions = (options)=>{
+function resolveSortType(options) {
     if (options === true) return 'alphabetical';
     if (options === false) return false;
     return validOptions.has(options) ? options : false;
-};
-class AttributeTokenChain {
+}
+
+// class, rel, ping
+class ListAttributeTokenChain {
     addFromNodeAttrsArray(attrValuesArray) {
         attrValuesArray.forEach((attrValue)=>{
-            if (this.freqData.has(attrValue)) {
-                this.freqData.set(attrValue, this.freqData.get(attrValue) + 1);
+            if (!attrValue) {
+                return;
+            }
+            if (this.tokenCounts.has(attrValue)) {
+                this.tokenCounts.set(attrValue, this.tokenCounts.get(attrValue) + 1);
             } else {
-                this.freqData.set(attrValue, 1);
+                this.tokenCounts.set(attrValue, 1);
             }
         });
     }
     createSortOrder() {
-        const _sortOrder = [
-            ...this.freqData.entries()
+        const nextSortOrder = [
+            ...this.tokenCounts.entries()
         ];
-        _sortOrder.sort((a, b)=>b[1] - a[1]);
-        this.sortOrder = _sortOrder.map((i)=>i[0]);
+        nextSortOrder.sort((a, b)=>b[1] - a[1] || a[0].localeCompare(b[0]));
+        this.sortedTokens = nextSortOrder.map((i)=>i[0]);
     }
     sortFromNodeAttrsArray(attrValuesArray) {
         const resultArray = [];
-        if (!this.sortOrder) {
+        const tokenCounts = new Map();
+        attrValuesArray.forEach((attrValue)=>{
+            var _tokenCounts_get;
+            if (!attrValue) {
+                return;
+            }
+            tokenCounts.set(attrValue, ((_tokenCounts_get = tokenCounts.get(attrValue)) != null ? _tokenCounts_get : 0) + 1);
+        });
+        if (!this.sortedTokens) {
             this.createSortOrder();
         }
-        this.sortOrder.forEach((k)=>{
-            if (attrValuesArray.includes(k)) {
+        this.sortedTokens.forEach((k)=>{
+            const count = tokenCounts.get(k);
+            if (!count) {
+                return;
+            }
+            for(let i = 0; i < count; i += 1){
                 resultArray.push(k);
             }
         });
         return resultArray;
     }
     constructor(){
-        /** <attr, frequency> */ this.freqData = new Map();
-        this.sortOrder = null;
+        /** <attr, frequency> */ this.tokenCounts = new Map();
+        this.sortedTokens = null;
     }
 }
 /** Sort values inside list-like attributes (e.g. class, rel) */ const mod = {
     default (tree, options, moduleOptions) {
-        const sortType = processModuleOptions(moduleOptions);
+        const sortType = resolveSortType(moduleOptions);
         if (sortType === 'alphabetical') {
             return sortAttributesWithListsInAlphabeticalOrder(tree);
         }
@@ -57,58 +73,51 @@ class AttributeTokenChain {
         return tree;
     }
 };
-function sortAttributesWithListsInAlphabeticalOrder(tree) {
+const splitListAttributeValues = (attrValue)=>attrValue.split(/\s+/).filter(Boolean);
+function walkListAttributes(tree, walkFn) {
     tree.walk((node)=>{
         if (!node.attrs) {
             return node;
         }
-        Object.keys(node.attrs).forEach((attrName)=>{
+        const tagName = node.tag ? node.tag.toLowerCase() : undefined;
+        Object.entries(node.attrs).forEach(([attrName, attrValues])=>{
             const attrNameLower = attrName.toLowerCase();
-            if (!attributesWithLists.has(attrNameLower)) {
+            if (!isListAttribute(attrNameLower, tagName) || typeof attrValues !== 'string') {
                 return;
             }
-            const attrValues = node.attrs[attrName].split(/\s/);
-            node.attrs[attrName] = attrValues.sort((a, b)=>{
-                // @ts-expect-error -- deliberately use minus operator to sort things
-                return typeof a.localeCompare === 'function' ? a.localeCompare(b) : a - b;
-            }).join(' ');
+            walkFn(node.attrs, attrName, attrValues);
         });
         return node;
     });
+}
+function sortAttributesWithListsInAlphabeticalOrder(tree) {
+    walkListAttributes(tree, (nodeAttrs, attrName, attrValues)=>{
+        const values = splitListAttributeValues(attrValues);
+        if (values.length < 2) {
+            return;
+        }
+        nodeAttrs[attrName] = values.sort((a, b)=>{
+            // @ts-expect-error -- deliberately use minus operator to sort things
+            return typeof a.localeCompare === 'function' ? a.localeCompare(b) : a - b;
+        }).join(' ');
+    });
     return tree;
 }
 function sortAttributesWithListsByFrequency(tree) {
-    const tokenChainObj = {}; // <attrNameLower: AttributeTokenChain>[]
+    const tokenChainObj = {};
     // Traverse through tree to get frequency
-    tree.walk((node)=>{
-        if (!node.attrs) {
-            return node;
-        }
-        Object.entries(node.attrs).forEach(([attrName, attrValues])=>{
-            const attrNameLower = attrName.toLowerCase();
-            if (!attributesWithLists.has(attrNameLower)) {
-                return;
-            }
-            tokenChainObj[attrNameLower] = tokenChainObj[attrNameLower] || new AttributeTokenChain();
-            tokenChainObj[attrNameLower].addFromNodeAttrsArray(attrValues.split(/\s/));
-        });
-        return node;
+    walkListAttributes(tree, (_nodeAttrs, attrName, attrValues)=>{
+        const attrNameLower = attrName.toLowerCase();
+        tokenChainObj[attrNameLower] = tokenChainObj[attrNameLower] || new ListAttributeTokenChain();
+        tokenChainObj[attrNameLower].addFromNodeAttrsArray(splitListAttributeValues(attrValues));
     });
     // Traverse through tree again, this time sort the attribute values
-    tree.walk((node)=>{
-        if (!node.attrs) {
-            return node;
+    walkListAttributes(tree, (nodeAttrs, attrName, attrValues)=>{
+        const attrNameLower = attrName.toLowerCase();
+        if (!tokenChainObj[attrNameLower]) {
+            return;
         }
-        Object.entries(node.attrs).forEach(([attrName, attrValues])=>{
-            const attrNameLower = attrName.toLowerCase();
-            if (!attributesWithLists.has(attrNameLower)) {
-                return;
-            }
-            if (tokenChainObj[attrNameLower]) {
-                node.attrs[attrName] = tokenChainObj[attrNameLower].sortFromNodeAttrsArray(attrValues.split(/\s/)).join(' ');
-            }
-        });
-        return node;
+        nodeAttrs[attrName] = tokenChainObj[attrNameLower].sortFromNodeAttrsArray(splitListAttributeValues(attrValues)).join(' ');
     });
     return tree;
 }

package/dist/helpers.d.ts

@@ -7,10 +7,17 @@ declare function isComment(content: PostHTMLNodeLike | null): boolean;
 declare function isConditionalComment(content: string): boolean;
 declare function isStyleNode(node: PostHTML.Node): boolean | undefined;
 declare function extractCssFromStyleNode(node: PostHTML.Node): string | undefined;
+declare function stripCssCdata(css: string): {
+    strippedCss: string;
+    isCdataWrapped: boolean;
+};
+declare function wrapCssCdata(css: string, isCdataWrapped: boolean): string;
+declare function isCssStyleType(node: PostHTML.Node): boolean;
+declare function normalizeMimeType(value: string): string;
 declare function isEventHandler(attributeName: string): boolean | "";
 declare function extractTextContentFromNode(node: PostHTML.Node): string;
 declare function optionalImport<Module = unknown, Default = Module>(moduleName: string): Promise<(Module & {
     default?: Default;
 }) | NonNullable<Default> | null>;
 
-export { extractCssFromStyleNode, extractTextContentFromNode, isAmpBoilerplate, isComment, isConditionalComment, isEventHandler, isStyleNode, optionalImport };
+export { extractCssFromStyleNode, extractTextContentFromNode, isAmpBoilerplate, isComment, isConditionalComment, isCssStyleType, isEventHandler, isStyleNode, normalizeMimeType, optionalImport, stripCssCdata, wrapCssCdata };

package/dist/helpers.js

@@ -5,6 +5,8 @@ const ampBoilerplateAttributes = [
     'amp4ads-boilerplate',
     'amp4email-boilerplate'
 ];
+const cssCdataStart = '<![CDATA[';
+const cssCdataEnd = ']]>';
 function isAmpBoilerplate(node) {
     if (!node.attrs) {
         return false;
@@ -32,6 +34,48 @@ function isStyleNode(node) {
 function extractCssFromStyleNode(node) {
     return Array.isArray(node.content) ? node.content.join(' ') : node.content;
 }
+function stripCssCdata(css) {
+    const trimmed = css.trim();
+    if (!trimmed.startsWith(cssCdataStart) || !trimmed.endsWith(cssCdataEnd)) {
+        return {
+            strippedCss: css,
+            isCdataWrapped: false
+        };
+    }
+    const strippedCss = trimmed.slice(cssCdataStart.length, trimmed.length - cssCdataEnd.length);
+    return {
+        strippedCss,
+        isCdataWrapped: true
+    };
+}
+function wrapCssCdata(css, isCdataWrapped) {
+    if (!isCdataWrapped) {
+        return css;
+    }
+    return `${cssCdataStart}${css}${cssCdataEnd}`;
+}
+function isCssStyleType(node) {
+    if (!node.attrs || !('type' in node.attrs)) {
+        return true;
+    }
+    const rawType = node.attrs.type;
+    if (rawType === '') {
+        return true;
+    }
+    if (typeof rawType !== 'string') {
+        return false;
+    }
+    const normalizedType = rawType.trim().toLowerCase();
+    return /^text\/css(?:$|\s*;)/.test(normalizedType);
+}
+function normalizeMimeType(value) {
+    const trimmed = value.trim();
+    if (!trimmed) {
+        return '';
+    }
+    const [mimeType] = trimmed.split(';');
+    return mimeType.trim().toLowerCase();
+}
 function isEventHandler(attributeName) {
     return attributeName && attributeName.slice(0, 2).toLowerCase() === 'on' && attributeName.length >= 5;
 }
@@ -67,6 +111,10 @@ exports.extractTextContentFromNode = extractTextContentFromNode;
 exports.isAmpBoilerplate = isAmpBoilerplate;
 exports.isComment = isComment;
 exports.isConditionalComment = isConditionalComment;
+exports.isCssStyleType = isCssStyleType;
 exports.isEventHandler = isEventHandler;
 exports.isStyleNode = isStyleNode;
+exports.normalizeMimeType = normalizeMimeType;
 exports.optionalImport = optionalImport;
+exports.stripCssCdata = stripCssCdata;
+exports.wrapCssCdata = wrapCssCdata;

package/dist/helpers.mjs

@@ -3,6 +3,8 @@ const ampBoilerplateAttributes = [
     'amp4ads-boilerplate',
     'amp4email-boilerplate'
 ];
+const cssCdataStart = '<![CDATA[';
+const cssCdataEnd = ']]>';
 function isAmpBoilerplate(node) {
     if (!node.attrs) {
         return false;
@@ -30,6 +32,48 @@ function isStyleNode(node) {
 function extractCssFromStyleNode(node) {
     return Array.isArray(node.content) ? node.content.join(' ') : node.content;
 }
+function stripCssCdata(css) {
+    const trimmed = css.trim();
+    if (!trimmed.startsWith(cssCdataStart) || !trimmed.endsWith(cssCdataEnd)) {
+        return {
+            strippedCss: css,
+            isCdataWrapped: false
+        };
+    }
+    const strippedCss = trimmed.slice(cssCdataStart.length, trimmed.length - cssCdataEnd.length);
+    return {
+        strippedCss,
+        isCdataWrapped: true
+    };
+}
+function wrapCssCdata(css, isCdataWrapped) {
+    if (!isCdataWrapped) {
+        return css;
+    }
+    return `${cssCdataStart}${css}${cssCdataEnd}`;
+}
+function isCssStyleType(node) {
+    if (!node.attrs || !('type' in node.attrs)) {
+        return true;
+    }
+    const rawType = node.attrs.type;
+    if (rawType === '') {
+        return true;
+    }
+    if (typeof rawType !== 'string') {
+        return false;
+    }
+    const normalizedType = rawType.trim().toLowerCase();
+    return /^text\/css(?:$|\s*;)/.test(normalizedType);
+}
+function normalizeMimeType(value) {
+    const trimmed = value.trim();
+    if (!trimmed) {
+        return '';
+    }
+    const [mimeType] = trimmed.split(';');
+    return mimeType.trim().toLowerCase();
+}
 function isEventHandler(attributeName) {
     return attributeName && attributeName.slice(0, 2).toLowerCase() === 'on' && attributeName.length >= 5;
 }
@@ -60,4 +104,4 @@ async function optionalImport(moduleName) {
     }
 }
 
-export { extractCssFromStyleNode, extractTextContentFromNode, isAmpBoilerplate, isComment, isConditionalComment, isEventHandler, isStyleNode, optionalImport };
+export { extractCssFromStyleNode, extractTextContentFromNode, isAmpBoilerplate, isComment, isConditionalComment, isCssStyleType, isEventHandler, isStyleNode, normalizeMimeType, optionalImport, stripCssCdata, wrapCssCdata };

package/dist/index.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';
 }
@@ -77,4 +110,4 @@ declare function htmlMinimizerWebpackPluginMinify(input: {
 }>;
 
 export { htmlnano as default, getRequiredOptionalDependencies, htmlMinimizerWebpackPluginMinify, loadConfig, presets, process };
-export type { HtmlnanoModule, HtmlnanoModuleAttrsHandler, HtmlnanoModuleContentHandler, HtmlnanoModuleNodeHandler, HtmlnanoOptions, HtmlnanoOptionsConfigFile, HtmlnanoPredefinedPreset, HtmlnanoPredefinedPresets, HtmlnanoPreset, PostHTMLNodeLike, PostHTMLTreeLike };
+export type { HtmlnanoModule, HtmlnanoModuleAttrsHandler, HtmlnanoModuleContentHandler, HtmlnanoModuleNodeHandler, HtmlnanoOptions, HtmlnanoOptionsConfigFile, HtmlnanoPredefinedPreset, HtmlnanoPredefinedPresets, HtmlnanoPreset, HtmlnanoTemplateRule, MinifyHtmlTemplateOptions, PostHTMLNodeLike, PostHTMLTreeLike };

package/dist/index.js

@@ -125,14 +125,17 @@ const modules = {
     mergeStyles: ()=>interop(import('./_modules/mergeStyles.js')),
     minifyConditionalComments: ()=>interop(import('./_modules/minifyConditionalComments.js')),
     minifyCss: ()=>interop(import('./_modules/minifyCss.js')),
+    minifyHtmlTemplate: ()=>interop(import('./_modules/minifyHtmlTemplate.js')),
     minifyJs: ()=>interop(import('./_modules/minifyJs.js')),
     minifyJson: ()=>interop(import('./_modules/minifyJson.js')),
+    minifyAttributes: ()=>interop(import('./_modules/minifyAttributes.js')),
     minifySvg: ()=>interop(import('./_modules/minifySvg.js')),
     minifyUrls: ()=>interop(import('./_modules/minifyUrls.js')),
     normalizeAttributeValues: ()=>interop(import('./_modules/normalizeAttributeValues.js')),
     removeAttributeQuotes: ()=>interop(import('./_modules/removeAttributeQuotes.js')),
     removeComments: ()=>interop(import('./_modules/removeComments.js')),
     removeEmptyAttributes: ()=>interop(import('./_modules/removeEmptyAttributes.js')),
+    removeEmptyElements: ()=>interop(import('./_modules/removeEmptyElements.js')),
     removeOptionalTags: ()=>interop(import('./_modules/removeOptionalTags.js')),
     removeRedundantAttributes: ()=>interop(import('./_modules/removeRedundantAttributes.js')),
     removeUnusedCss: ()=>interop(import('./_modules/removeUnusedCss.js')),
@@ -152,7 +155,13 @@ const htmlnano = Object.assign(function htmlnano(optionsRun = {}, presetRun) {
             ...options
         };
         let promise = Promise.resolve(tree);
+        const nonModuleOptions = new Set([
+            'skipInternalWarnings'
+        ]);
         for (const [moduleName, moduleOptions] of Object.entries(options)){
+            if (nonModuleOptions.has(moduleName)) {
+                continue;
+            }
             if (!moduleOptions) {
                 continue;
             }
@@ -179,15 +188,19 @@ const htmlnano = Object.assign(function htmlnano(optionsRun = {}, presetRun) {
             }
             const mod = moduleName in modules ? await modules[moduleName]() : await import(`./_modules/${moduleName}.mjs`);
             if (typeof mod.onAttrs === 'function') {
+                // eslint-disable-next-line @typescript-eslint/no-explicit-any -- module options are generic
                 attrsHandlers.push(mod.onAttrs(options, moduleOptions));
             }
             if (typeof mod.onContent === 'function') {
+                // eslint-disable-next-line @typescript-eslint/no-explicit-any -- module options are generic
                 contentsHandlers.push(mod.onContent(options, moduleOptions));
             }
             if (typeof mod.onNode === 'function') {
+                // eslint-disable-next-line @typescript-eslint/no-explicit-any -- module options are generic
                 nodeHandlers.push(mod.onNode(options, moduleOptions));
             }
             if (typeof mod.default === 'function') {
+                // eslint-disable-next-line @typescript-eslint/no-explicit-any -- module options are generic
                 promise = promise.then(async (tree)=>await mod.default(tree, options, moduleOptions));
             }
         }

package/dist/index.mjs

@@ -116,14 +116,17 @@ const modules = {
     mergeStyles: ()=>interop(import('./_modules/mergeStyles.mjs')),
     minifyConditionalComments: ()=>interop(import('./_modules/minifyConditionalComments.mjs')),
     minifyCss: ()=>interop(import('./_modules/minifyCss.mjs')),
+    minifyHtmlTemplate: ()=>interop(import('./_modules/minifyHtmlTemplate.mjs')),
     minifyJs: ()=>interop(import('./_modules/minifyJs.mjs')),
     minifyJson: ()=>interop(import('./_modules/minifyJson.mjs')),
+    minifyAttributes: ()=>interop(import('./_modules/minifyAttributes.mjs')),
     minifySvg: ()=>interop(import('./_modules/minifySvg.mjs')),
     minifyUrls: ()=>interop(import('./_modules/minifyUrls.mjs')),
     normalizeAttributeValues: ()=>interop(import('./_modules/normalizeAttributeValues.mjs')),
     removeAttributeQuotes: ()=>interop(import('./_modules/removeAttributeQuotes.mjs')),
     removeComments: ()=>interop(import('./_modules/removeComments.mjs')),
     removeEmptyAttributes: ()=>interop(import('./_modules/removeEmptyAttributes.mjs')),
+    removeEmptyElements: ()=>interop(import('./_modules/removeEmptyElements.mjs')),
     removeOptionalTags: ()=>interop(import('./_modules/removeOptionalTags.mjs')),
     removeRedundantAttributes: ()=>interop(import('./_modules/removeRedundantAttributes.mjs')),
     removeUnusedCss: ()=>interop(import('./_modules/removeUnusedCss.mjs')),
@@ -143,7 +146,13 @@ const htmlnano = Object.assign(function htmlnano(optionsRun = {}, presetRun) {
             ...options
         };
         let promise = Promise.resolve(tree);
+        const nonModuleOptions = new Set([
+            'skipInternalWarnings'
+        ]);
         for (const [moduleName, moduleOptions] of Object.entries(options)){
+            if (nonModuleOptions.has(moduleName)) {
+                continue;
+            }
             if (!moduleOptions) {
                 continue;
             }
@@ -170,15 +179,19 @@ const htmlnano = Object.assign(function htmlnano(optionsRun = {}, presetRun) {
             }
             const mod = moduleName in modules ? await modules[moduleName]() : await import(`./_modules/${moduleName}.mjs`);
             if (typeof mod.onAttrs === 'function') {
+                // eslint-disable-next-line @typescript-eslint/no-explicit-any -- module options are generic
                 attrsHandlers.push(mod.onAttrs(options, moduleOptions));
             }
             if (typeof mod.onContent === 'function') {
+                // eslint-disable-next-line @typescript-eslint/no-explicit-any -- module options are generic
                 contentsHandlers.push(mod.onContent(options, moduleOptions));
             }
             if (typeof mod.onNode === 'function') {
+                // eslint-disable-next-line @typescript-eslint/no-explicit-any -- module options are generic
                 nodeHandlers.push(mod.onNode(options, moduleOptions));
             }
             if (typeof mod.default === 'function') {
+                // eslint-disable-next-line @typescript-eslint/no-explicit-any -- module options are generic
                 promise = promise.then(async (tree)=>await mod.default(tree, options, moduleOptions));
             }
         }

package/dist/presets/ampSafe.d.ts

@@ -2,15 +2,23 @@ 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 HtmlnanoTemplateRule = {
+    tag: string;
+    attrs?: Record<string, string | boolean | void>;
+};
+type MinifyHtmlTemplateOptions = boolean | HtmlnanoTemplateRule[];
 interface HtmlnanoOptions {
     skipConfigLoading?: boolean;
     configPath?: string;
@@ -26,17 +34,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/presets/max.d.ts

@@ -2,15 +2,23 @@ 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 HtmlnanoTemplateRule = {
+    tag: string;
+    attrs?: Record<string, string | boolean | void>;
+};
+type MinifyHtmlTemplateOptions = boolean | HtmlnanoTemplateRule[];
 interface HtmlnanoOptions {
     skipConfigLoading?: boolean;
     configPath?: string;
@@ -26,17 +34,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';
 }