htmlnano 2.1.5 → 3.1.0

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/bin.js

@@ -0,0 +1,34 @@
+#!/usr/bin/env node
+var commander = require('commander');
+var fs = require('fs');
+var process = require('process');
+var index_js = require('./index.js');
+
+function _interopDefault (e) { return e && e.__esModule ? e : { default: e }; }
+
+var fs__default = /*#__PURE__*/_interopDefault(fs);
+var process__default = /*#__PURE__*/_interopDefault(process);
+
+commander.program.name('htmlnano').description('Minify HTML with htmlnano').argument('[input]', 'input file', '-').option('-o, --output <file>', 'output file', '-').option('-p, --preset <preset>', 'preset to use', 'safe').option('-c, --config <file>', 'path to config file').action(async (input, options)=>{
+    const { preset, output } = options;
+    if (!preset || !(preset in index_js.presets)) {
+        const available = Object.keys(index_js.presets).join(', ');
+        process__default.default.stderr.write(`Unknown preset: ${preset}. Available presets: ${available}\n`);
+        process__default.default.exitCode = 1;
+        return;
+    }
+    const html = fs__default.default.readFileSync(input && input !== '-' ? input : 0, 'utf8');
+    const key = preset;
+    const chosenPreset = index_js.presets[key];
+    const htmlnanoOptions = {};
+    if (options.config) {
+        htmlnanoOptions.configPath = options.config;
+    }
+    const result = await index_js.process(html, htmlnanoOptions, chosenPreset);
+    if (output && output !== '-') {
+        fs__default.default.writeFileSync(output, result.html);
+    } else {
+        process__default.default.stdout.write(result.html);
+    }
+});
+commander.program.parse();

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,18 +2,27 @@ import PostHTML from 'posthtml';
 import { MinifyOptions } from 'terser';
 import { Options } from 'cssnano';
 import { Config } from 'svgo';
+import { UserDefinedOptions } from 'purgecss';
 
 type PostHTMLTreeLike = [PostHTML.Node] & PostHTML.NodeAPI & {
     options?: {
         quoteAllAttributes?: boolean | undefined;
+        quoteStyle?: 0 | 1 | 2 | undefined;
+        replaceQuote?: boolean | undefined;
     } | undefined;
     render(): string;
     render(node: PostHTML.Node | PostHTMLTreeLike, renderOptions?: any): string;
 };
 type MaybeArray<T> = T | Array<T>;
 type PostHTMLNodeLike = PostHTML.Node | string;
+type HtmlnanoTemplateRule = {
+    tag: string;
+    attrs?: Record<string, string | boolean | void>;
+};
+type MinifyHtmlTemplateOptions = boolean | HtmlnanoTemplateRule[];
 interface HtmlnanoOptions {
     skipConfigLoading?: boolean;
+    configPath?: string;
     skipInternalWarnings?: boolean;
     collapseAttributeWhitespace?: boolean;
     collapseBooleanAttributes?: {
@@ -26,25 +35,50 @@ 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';
 }
-interface HtmlnanoPreset extends Omit<HtmlnanoOptions, 'skipConfigLoading'> {
+interface HtmlnanoPreset extends Omit<HtmlnanoOptions, 'skipConfigLoading' | 'configPath'> {
 }
 type HtmlnanoPredefinedPreset = 'safe' | 'ampSafe' | 'max';
 type HtmlnanoPredefinedPresets = Record<HtmlnanoPredefinedPreset, HtmlnanoPreset>;
-type HtmlnanoOptionsConfigFile = Omit<HtmlnanoOptions, 'skipConfigLoading'> & {
+type HtmlnanoOptionsConfigFile = Omit<HtmlnanoOptions, 'skipConfigLoading' | 'configPath'> & {
     preset?: HtmlnanoPredefinedPreset;
 };
 type HtmlnanoModuleAttrsHandler = (attrs: Record<string, string | boolean | void>, node: PostHTML.Node) => Record<string, string | boolean | void>;
@@ -58,7 +92,8 @@ type HtmlnanoModule<Options = any> = {
     default?: (tree: PostHTMLTreeLike, options: Partial<HtmlnanoOptions>, moduleOptions: OptionalOptions<Options>) => PostHTMLTreeLike | Promise<PostHTMLTreeLike>;
 };
 
-declare function loadConfig(options?: HtmlnanoOptions, preset?: HtmlnanoPreset, configPath?: string): [Partial<HtmlnanoOptions>, HtmlnanoPreset];
+declare const presets: HtmlnanoPredefinedPresets;
+declare function loadConfig(options?: HtmlnanoOptions, preset?: HtmlnanoPreset): [Partial<HtmlnanoOptions>, HtmlnanoPreset];
 declare const htmlnano: ((optionsRun?: HtmlnanoOptions, presetRun?: HtmlnanoPreset) => PostHTML.Plugin<never>) & {
     presets: HtmlnanoPredefinedPresets;
     getRequiredOptionalDependencies: typeof getRequiredOptionalDependencies;
@@ -74,5 +109,5 @@ declare function htmlMinimizerWebpackPluginMinify(input: {
     code: string;
 }>;
 
-export { htmlnano as default, getRequiredOptionalDependencies, htmlMinimizerWebpackPluginMinify, loadConfig, process };
-export type { HtmlnanoModule, HtmlnanoModuleAttrsHandler, HtmlnanoModuleContentHandler, HtmlnanoModuleNodeHandler, HtmlnanoOptions, HtmlnanoOptionsConfigFile, HtmlnanoPredefinedPreset, HtmlnanoPredefinedPresets, HtmlnanoPreset, PostHTMLNodeLike, PostHTMLTreeLike };
+export { htmlnano as default, getRequiredOptionalDependencies, htmlMinimizerWebpackPluginMinify, loadConfig, presets, process };
+export type { HtmlnanoModule, HtmlnanoModuleAttrsHandler, HtmlnanoModuleContentHandler, HtmlnanoModuleNodeHandler, HtmlnanoOptions, HtmlnanoOptionsConfigFile, HtmlnanoPredefinedPreset, HtmlnanoPredefinedPresets, HtmlnanoPreset, HtmlnanoTemplateRule, MinifyHtmlTemplateOptions, PostHTMLNodeLike, PostHTMLTreeLike };

package/dist/index.js

@@ -18,8 +18,8 @@ const presets = {
     ampSafe: ampSafePreset__default.default,
     max: maxPreset__default.default
 };
-function loadConfig(options, preset, configPath) {
-    const { skipConfigLoading = false, ...rest } = options || {};
+function loadConfig(options, preset) {
+    const { skipConfigLoading = false, configPath, ...rest } = options || {};
     let restConfig = rest;
     if (!skipConfigLoading) {
         const explorer = cosmiconfig.cosmiconfigSync('htmlnano');
@@ -32,9 +32,10 @@ function loadConfig(options, preset, configPath) {
                 }
                 delete rc.config.preset;
             }
-            if (!options) {
-                restConfig = rc.config;
-            }
+            restConfig = {
+                ...rc.config,
+                ...restConfig
+            };
         }
     }
     return [
@@ -124,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')),
@@ -151,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;
             }
@@ -178,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));
             }
         }
@@ -273,4 +287,5 @@ exports.default = htmlnano;
 exports.getRequiredOptionalDependencies = getRequiredOptionalDependencies;
 exports.htmlMinimizerWebpackPluginMinify = htmlMinimizerWebpackPluginMinify;
 exports.loadConfig = loadConfig;
+exports.presets = presets;
 exports.process = process;

package/dist/index.mjs

@@ -9,8 +9,8 @@ const presets = {
     ampSafe: ampSafePreset,
     max: maxPreset
 };
-function loadConfig(options, preset, configPath) {
-    const { skipConfigLoading = false, ...rest } = options || {};
+function loadConfig(options, preset) {
+    const { skipConfigLoading = false, configPath, ...rest } = options || {};
     let restConfig = rest;
     if (!skipConfigLoading) {
         const explorer = cosmiconfigSync('htmlnano');
@@ -23,9 +23,10 @@ function loadConfig(options, preset, configPath) {
                 }
                 delete rc.config.preset;
             }
-            if (!options) {
-                restConfig = rc.config;
-            }
+            restConfig = {
+                ...rc.config,
+                ...restConfig
+            };
         }
     }
     return [
@@ -115,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')),
@@ -142,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;
             }
@@ -169,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));
             }
         }
@@ -260,4 +274,4 @@ if (typeof module !== 'undefined') {
     module.exports = htmlnano;
 }
 
-export { htmlnano as default, getRequiredOptionalDependencies, htmlMinimizerWebpackPluginMinify, loadConfig, process };
+export { htmlnano as default, getRequiredOptionalDependencies, htmlMinimizerWebpackPluginMinify, loadConfig, presets, process };

package/dist/presets/ampSafe.d.ts

@@ -2,17 +2,26 @@ 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;
     skipInternalWarnings?: boolean;
     collapseAttributeWhitespace?: boolean;
     collapseBooleanAttributes?: {
@@ -25,21 +34,46 @@ 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';
 }
-interface HtmlnanoPreset extends Omit<HtmlnanoOptions, 'skipConfigLoading'> {
+interface HtmlnanoPreset extends Omit<HtmlnanoOptions, 'skipConfigLoading' | 'configPath'> {
 }
 
 declare const _default: HtmlnanoPreset;