htmlnano 3.0.0 → 3.1.0

package/dist/_modules/sortAttributesWithLists.js

@@ -15,6 +15,9 @@ const processModuleOptions = (options)=>{
 class AttributeTokenChain {
     addFromNodeAttrsArray(attrValuesArray) {
         attrValuesArray.forEach((attrValue)=>{
+            if (!attrValue) {
+                return;
+            }
             if (this.freqData.has(attrValue)) {
                 this.freqData.set(attrValue, this.freqData.get(attrValue) + 1);
             } else {
@@ -26,16 +29,28 @@ class AttributeTokenChain {
         const _sortOrder = [
             ...this.freqData.entries()
         ];
-        _sortOrder.sort((a, b)=>b[1] - a[1]);
+        _sortOrder.sort((a, b)=>b[1] - a[1] || a[0].localeCompare(b[0]));
         this.sortOrder = _sortOrder.map((i)=>i[0]);
     }
     sortFromNodeAttrsArray(attrValuesArray) {
         const resultArray = [];
+        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.sortOrder) {
             this.createSortOrder();
         }
         this.sortOrder.forEach((k)=>{
-            if (attrValuesArray.includes(k)) {
+            const count = tokenCounts.get(k);
+            if (!count) {
+                return;
+            }
+            for(let i = 0; i < count; i += 1){
                 resultArray.push(k);
             }
         });
@@ -59,17 +74,22 @@ class AttributeTokenChain {
         return tree;
     }
 };
+const splitListAttributeValues = (attrValue)=>attrValue.split(/\s+/).filter(Boolean);
 function sortAttributesWithListsInAlphabeticalOrder(tree) {
     tree.walk((node)=>{
         if (!node.attrs) {
             return node;
         }
+        const tagName = node.tag ? node.tag.toLowerCase() : undefined;
         Object.keys(node.attrs).forEach((attrName)=>{
             const attrNameLower = attrName.toLowerCase();
-            if (!collapseAttributeWhitespace_js.attributesWithLists.has(attrNameLower)) {
+            if (!collapseAttributeWhitespace_js.isListAttribute(attrNameLower, tagName)) {
+                return;
+            }
+            const attrValues = splitListAttributeValues(node.attrs[attrName]);
+            if (attrValues.length < 2) {
                 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;
@@ -86,13 +106,14 @@ function sortAttributesWithListsByFrequency(tree) {
         if (!node.attrs) {
             return node;
         }
+        const tagName = node.tag ? node.tag.toLowerCase() : undefined;
         Object.entries(node.attrs).forEach(([attrName, attrValues])=>{
             const attrNameLower = attrName.toLowerCase();
-            if (!collapseAttributeWhitespace_js.attributesWithLists.has(attrNameLower)) {
+            if (!collapseAttributeWhitespace_js.isListAttribute(attrNameLower, tagName)) {
                 return;
             }
             tokenChainObj[attrNameLower] = tokenChainObj[attrNameLower] || new AttributeTokenChain();
-            tokenChainObj[attrNameLower].addFromNodeAttrsArray(attrValues.split(/\s/));
+            tokenChainObj[attrNameLower].addFromNodeAttrsArray(splitListAttributeValues(attrValues));
         });
         return node;
     });
@@ -101,13 +122,14 @@ function sortAttributesWithListsByFrequency(tree) {
         if (!node.attrs) {
             return node;
         }
+        const tagName = node.tag ? node.tag.toLowerCase() : undefined;
         Object.entries(node.attrs).forEach(([attrName, attrValues])=>{
             const attrNameLower = attrName.toLowerCase();
-            if (!collapseAttributeWhitespace_js.attributesWithLists.has(attrNameLower)) {
+            if (!collapseAttributeWhitespace_js.isListAttribute(attrNameLower, tagName)) {
                 return;
             }
             if (tokenChainObj[attrNameLower]) {
-                node.attrs[attrName] = tokenChainObj[attrNameLower].sortFromNodeAttrsArray(attrValues.split(/\s/)).join(' ');
+                node.attrs[attrName] = tokenChainObj[attrNameLower].sortFromNodeAttrsArray(splitListAttributeValues(attrValues)).join(' ');
             }
         });
         return node;

package/dist/_modules/sortAttributesWithLists.mjs

@@ -1,4 +1,4 @@
-import { attributesWithLists } from './collapseAttributeWhitespace.mjs';
+import { isListAttribute } from './collapseAttributeWhitespace.mjs';
 
 // class, rel, ping
 const validOptions = new Set([
@@ -13,6 +13,9 @@ const processModuleOptions = (options)=>{
 class AttributeTokenChain {
     addFromNodeAttrsArray(attrValuesArray) {
         attrValuesArray.forEach((attrValue)=>{
+            if (!attrValue) {
+                return;
+            }
             if (this.freqData.has(attrValue)) {
                 this.freqData.set(attrValue, this.freqData.get(attrValue) + 1);
             } else {
@@ -24,16 +27,28 @@ class AttributeTokenChain {
         const _sortOrder = [
             ...this.freqData.entries()
         ];
-        _sortOrder.sort((a, b)=>b[1] - a[1]);
+        _sortOrder.sort((a, b)=>b[1] - a[1] || a[0].localeCompare(b[0]));
         this.sortOrder = _sortOrder.map((i)=>i[0]);
     }
     sortFromNodeAttrsArray(attrValuesArray) {
         const resultArray = [];
+        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.sortOrder) {
             this.createSortOrder();
         }
         this.sortOrder.forEach((k)=>{
-            if (attrValuesArray.includes(k)) {
+            const count = tokenCounts.get(k);
+            if (!count) {
+                return;
+            }
+            for(let i = 0; i < count; i += 1){
                 resultArray.push(k);
             }
         });
@@ -57,17 +72,22 @@ class AttributeTokenChain {
         return tree;
     }
 };
+const splitListAttributeValues = (attrValue)=>attrValue.split(/\s+/).filter(Boolean);
 function sortAttributesWithListsInAlphabeticalOrder(tree) {
     tree.walk((node)=>{
         if (!node.attrs) {
             return node;
         }
+        const tagName = node.tag ? node.tag.toLowerCase() : undefined;
         Object.keys(node.attrs).forEach((attrName)=>{
             const attrNameLower = attrName.toLowerCase();
-            if (!attributesWithLists.has(attrNameLower)) {
+            if (!isListAttribute(attrNameLower, tagName)) {
+                return;
+            }
+            const attrValues = splitListAttributeValues(node.attrs[attrName]);
+            if (attrValues.length < 2) {
                 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;
@@ -84,13 +104,14 @@ function sortAttributesWithListsByFrequency(tree) {
         if (!node.attrs) {
             return node;
         }
+        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)) {
                 return;
             }
             tokenChainObj[attrNameLower] = tokenChainObj[attrNameLower] || new AttributeTokenChain();
-            tokenChainObj[attrNameLower].addFromNodeAttrsArray(attrValues.split(/\s/));
+            tokenChainObj[attrNameLower].addFromNodeAttrsArray(splitListAttributeValues(attrValues));
         });
         return node;
     });
@@ -99,13 +120,14 @@ function sortAttributesWithListsByFrequency(tree) {
         if (!node.attrs) {
             return node;
         }
+        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)) {
                 return;
             }
             if (tokenChainObj[attrNameLower]) {
-                node.attrs[attrName] = tokenChainObj[attrNameLower].sortFromNodeAttrsArray(attrValues.split(/\s/)).join(' ');
+                node.attrs[attrName] = tokenChainObj[attrNameLower].sortFromNodeAttrsArray(splitListAttributeValues(attrValues)).join(' ');
             }
         });
         return node;

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';
 }