htmlnano 3.0.0 → 3.2.0

package/dist/_modules/minifySvg.js

@@ -6,6 +6,8 @@ var helpers_js = require('../helpers.js');
     async default (tree, options, svgoOptions) {
         const svgo = await helpers_js.optionalImport('svgo');
         if (!svgo) return tree;
+        const resolvedSvgoOptions = resolveSvgoOptions(svgoOptions);
+        const svgoOptionsWithDefaults = applySvgoDefaults(resolvedSvgoOptions);
         tree.match({
             tag: 'svg'
         }, (node)=>{
@@ -14,7 +16,7 @@ var helpers_js = require('../helpers.js');
                 quoteAllAttributes: true
             });
             try {
-                const result = svgo.optimize(svgStr, svgoOptions);
+                const result = svgo.optimize(svgStr, svgoOptionsWithDefaults);
                 // @ts-expect-error -- remove this node
                 node.tag = false;
                 node.attrs = {};
@@ -25,9 +27,25 @@ var helpers_js = require('../helpers.js');
                 return node;
             } catch (error) {
                 const isSvgoParserError = Boolean(error && typeof error === 'object' && 'name' in error && error.name === 'SvgoParserError');
-                if (!options.skipInternalWarnings && !isSvgoParserError) {
-                    console.error('htmlnano fails to minify the svg:');
-                    console.error(error);
+                if (!isSvgoParserError) {
+                    if (!options.skipInternalWarnings) {
+                        console.error('htmlnano fails to minify the svg:');
+                        console.error(error);
+                    }
+                    let fallbackSvgStr = svgStr;
+                    try {
+                        fallbackSvgStr = svgo.optimize(svgStr, {
+                            plugins: []
+                        }).data;
+                    } catch (unused) {
+                        fallbackSvgStr = svgStr;
+                    }
+                    // @ts-expect-error -- remove this node
+                    node.tag = false;
+                    node.attrs = {};
+                    node.content = [
+                        fallbackSvgStr
+                    ];
                 }
                 // We return the node as-is
                 return node;
@@ -36,5 +54,18 @@ var helpers_js = require('../helpers.js');
         return tree;
     }
 };
+function resolveSvgoOptions(svgoOptions) {
+    if (!svgoOptions || svgoOptions === true) {
+        return {};
+    }
+    return svgoOptions;
+}
+function applySvgoDefaults(svgoOptions) {
+    var _svgoOptions_multipass;
+    return {
+        ...svgoOptions,
+        multipass: (_svgoOptions_multipass = svgoOptions.multipass) != null ? _svgoOptions_multipass : true
+    };
+}
 
 exports.default = mod;

package/dist/_modules/minifySvg.mjs

@@ -4,6 +4,8 @@ import { optionalImport } from '../helpers.mjs';
     async default (tree, options, svgoOptions) {
         const svgo = await optionalImport('svgo');
         if (!svgo) return tree;
+        const resolvedSvgoOptions = resolveSvgoOptions(svgoOptions);
+        const svgoOptionsWithDefaults = applySvgoDefaults(resolvedSvgoOptions);
         tree.match({
             tag: 'svg'
         }, (node)=>{
@@ -12,7 +14,7 @@ import { optionalImport } from '../helpers.mjs';
                 quoteAllAttributes: true
             });
             try {
-                const result = svgo.optimize(svgStr, svgoOptions);
+                const result = svgo.optimize(svgStr, svgoOptionsWithDefaults);
                 // @ts-expect-error -- remove this node
                 node.tag = false;
                 node.attrs = {};
@@ -23,9 +25,25 @@ import { optionalImport } from '../helpers.mjs';
                 return node;
             } catch (error) {
                 const isSvgoParserError = Boolean(error && typeof error === 'object' && 'name' in error && error.name === 'SvgoParserError');
-                if (!options.skipInternalWarnings && !isSvgoParserError) {
-                    console.error('htmlnano fails to minify the svg:');
-                    console.error(error);
+                if (!isSvgoParserError) {
+                    if (!options.skipInternalWarnings) {
+                        console.error('htmlnano fails to minify the svg:');
+                        console.error(error);
+                    }
+                    let fallbackSvgStr = svgStr;
+                    try {
+                        fallbackSvgStr = svgo.optimize(svgStr, {
+                            plugins: []
+                        }).data;
+                    } catch (unused) {
+                        fallbackSvgStr = svgStr;
+                    }
+                    // @ts-expect-error -- remove this node
+                    node.tag = false;
+                    node.attrs = {};
+                    node.content = [
+                        fallbackSvgStr
+                    ];
                 }
                 // We return the node as-is
                 return node;
@@ -34,5 +52,18 @@ import { optionalImport } from '../helpers.mjs';
         return tree;
     }
 };
+function resolveSvgoOptions(svgoOptions) {
+    if (!svgoOptions || svgoOptions === true) {
+        return {};
+    }
+    return svgoOptions;
+}
+function applySvgoDefaults(svgoOptions) {
+    var _svgoOptions_multipass;
+    return {
+        ...svgoOptions,
+        multipass: (_svgoOptions_multipass = svgoOptions.multipass) != null ? _svgoOptions_multipass : true
+    };
+}
 
 export { mod as default };

package/dist/_modules/minifyUrls.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';
 }
@@ -52,6 +85,6 @@ type HtmlnanoModule<Options = any> = {
     default?: (tree: PostHTMLTreeLike, options: Partial<HtmlnanoOptions>, moduleOptions: OptionalOptions<Options>) => PostHTMLTreeLike | Promise<PostHTMLTreeLike>;
 };
 
-declare const mod: HtmlnanoModule;
+declare const mod: HtmlnanoModule<HtmlnanoOptions['minifyUrls']>;
 
 export { mod as default };

package/dist/_modules/minifyUrls.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';
 }
@@ -52,6 +85,6 @@ type HtmlnanoModule<Options = any> = {
     default?: (tree: PostHTMLTreeLike, options: Partial<HtmlnanoOptions>, moduleOptions: OptionalOptions<Options>) => PostHTMLTreeLike | Promise<PostHTMLTreeLike>;
 };
 
-declare const mod: HtmlnanoModule;
+declare const mod: HtmlnanoModule<HtmlnanoOptions['minifyUrls']>;
 
 export { mod as default };

package/dist/_modules/minifyUrls.js

@@ -118,21 +118,19 @@ let STORED_URL_BASE;
             for (const [attrName, attrValue] of Object.entries(node.attrs)){
                 const attrNameLower = attrName.toLowerCase();
                 if (isUriTypeAttribute(node.tag, attrNameLower)) {
-                    if (isJavaScriptUrl(attrValue)) {
-                        promises.push(minifyJavaScriptUrl(node, attrName, terser));
-                    } else {
-                        if (relateUrlInstance && attrValue) {
-                            // FIXME!
-                            // relateurl@1.0.0-alpha only supports URL while stable version (0.2.7) only supports string
-                            // the WHATWG URL API is very strict while attrValue might not be a valid URL
-                            // new URL should be used, and relateUrl#relate should be wrapped in try...catch after relateurl@1 is stable
-                            node.attrs[attrName] = relateUrlInstance.relate(attrValue);
-                        }
+                    if (typeof attrValue !== 'string') continue;
+                    const javascriptMatch = getJavaScriptUrlMatch(attrValue);
+                    if (javascriptMatch) {
+                        promises.push(minifyJavaScriptUrl(node, attrName, javascriptMatch, terser));
+                        continue;
+                    }
+                    if (relateUrlInstance) {
+                        node.attrs[attrName] = relateUrlValue(relateUrlInstance, attrValue);
                     }
                     continue;
                 }
                 if (isSrcsetAttribute(node.tag, attrNameLower)) {
-                    if (srcset && attrValue) {
+                    if (srcset && typeof attrValue === 'string') {
                         try {
                             const parsedSrcset = srcset.parseSrcset(attrValue, {
                                 strict: true
@@ -140,7 +138,7 @@ let STORED_URL_BASE;
                             node.attrs[attrName] = srcset.stringifySrcset(parsedSrcset.map((item)=>{
                                 if (relateUrlInstance) {
                                     // @ts-expect-error -- not actually readonly
-                                    item.url = relateUrlInstance.relate(item.url);
+                                    item.url = relateUrlValue(relateUrlInstance, item.url);
                                 }
                                 return item;
                             }));
@@ -157,24 +155,51 @@ let STORED_URL_BASE;
         return Promise.resolve(tree);
     }
 };
-function isJavaScriptUrl(url) {
-    return typeof url === 'string' && url.toLowerCase().startsWith(JAVASCRIPT_URL_PROTOCOL);
-}
 const jsWrapperStart = 'function a(){';
 const jsWrapperEnd = '}a();';
-function minifyJavaScriptUrl(node, attrName, terser) {
-    var _node_attrs;
-    if (!terser) return Promise.resolve();
-    let result = (_node_attrs = node.attrs) == null ? void 0 : _node_attrs[attrName];
-    if (result) {
-        result = jsWrapperStart + result.slice(JAVASCRIPT_URL_PROTOCOL.length) + jsWrapperEnd;
-        return terser.minify(result, {}) // Default Option is good enough
-        .then(({ code })=>{
-            const minifiedJs = code.substring(jsWrapperStart.length, code.length - jsWrapperEnd.length);
-            node.attrs[attrName] = JAVASCRIPT_URL_PROTOCOL + minifiedJs;
-        });
+const javascriptUrlRegex = /^(\s*)(javascript:)([\s\S]*)$/i;
+function getJavaScriptUrlMatch(url) {
+    const match = javascriptUrlRegex.exec(url);
+    if (!match) return null;
+    return {
+        leadingWhitespace: match[1],
+        code: match[3]
+    };
+}
+function getUrlScheme(value) {
+    const match = /^[a-z][a-z0-9+.-]*:/i.exec(value);
+    if (!match) return null;
+    return match[0].slice(0, -1).toLowerCase();
+}
+function shouldRelateUrlValue(value) {
+    const trimmed = value.trim();
+    if (!trimmed) return false;
+    if (trimmed.startsWith('#') || trimmed.startsWith('?')) return false;
+    const scheme = getUrlScheme(trimmed);
+    if (scheme) return scheme === 'http' || scheme === 'https';
+    return true;
+}
+function relateUrlValue(relateUrl, value) {
+    if (!shouldRelateUrlValue(value)) return value;
+    // FIXME!
+    // relateurl@1.0.0-alpha only supports URL while stable version (0.2.7) only supports string
+    // the WHATWG URL API is very strict while attrValue might not be a valid URL
+    // new URL should be used, and relateUrl#relate should be wrapped in try...catch after relateurl@1 is stable
+    try {
+        return relateUrl.relate(value);
+    } catch (unused) {
+        return value;
     }
-    return Promise.resolve();
+}
+function minifyJavaScriptUrl(node, attrName, match, terser) {
+    if (!terser) return Promise.resolve();
+    const result = jsWrapperStart + match.code + jsWrapperEnd;
+    return terser.minify(result, {}) // Default Option is good enough
+    .then(({ code })=>{
+        if (!code) return;
+        const minifiedJs = code.substring(jsWrapperStart.length, code.length - jsWrapperEnd.length);
+        node.attrs[attrName] = match.leadingWhitespace + JAVASCRIPT_URL_PROTOCOL + minifiedJs;
+    }).catch(()=>undefined);
 }
 
 exports.default = mod;

package/dist/_modules/minifyUrls.mjs

@@ -116,21 +116,19 @@ let STORED_URL_BASE;
             for (const [attrName, attrValue] of Object.entries(node.attrs)){
                 const attrNameLower = attrName.toLowerCase();
                 if (isUriTypeAttribute(node.tag, attrNameLower)) {
-                    if (isJavaScriptUrl(attrValue)) {
-                        promises.push(minifyJavaScriptUrl(node, attrName, terser));
-                    } else {
-                        if (relateUrlInstance && attrValue) {
-                            // FIXME!
-                            // relateurl@1.0.0-alpha only supports URL while stable version (0.2.7) only supports string
-                            // the WHATWG URL API is very strict while attrValue might not be a valid URL
-                            // new URL should be used, and relateUrl#relate should be wrapped in try...catch after relateurl@1 is stable
-                            node.attrs[attrName] = relateUrlInstance.relate(attrValue);
-                        }
+                    if (typeof attrValue !== 'string') continue;
+                    const javascriptMatch = getJavaScriptUrlMatch(attrValue);
+                    if (javascriptMatch) {
+                        promises.push(minifyJavaScriptUrl(node, attrName, javascriptMatch, terser));
+                        continue;
+                    }
+                    if (relateUrlInstance) {
+                        node.attrs[attrName] = relateUrlValue(relateUrlInstance, attrValue);
                     }
                     continue;
                 }
                 if (isSrcsetAttribute(node.tag, attrNameLower)) {
-                    if (srcset && attrValue) {
+                    if (srcset && typeof attrValue === 'string') {
                         try {
                             const parsedSrcset = srcset.parseSrcset(attrValue, {
                                 strict: true
@@ -138,7 +136,7 @@ let STORED_URL_BASE;
                             node.attrs[attrName] = srcset.stringifySrcset(parsedSrcset.map((item)=>{
                                 if (relateUrlInstance) {
                                     // @ts-expect-error -- not actually readonly
-                                    item.url = relateUrlInstance.relate(item.url);
+                                    item.url = relateUrlValue(relateUrlInstance, item.url);
                                 }
                                 return item;
                             }));
@@ -155,24 +153,51 @@ let STORED_URL_BASE;
         return Promise.resolve(tree);
     }
 };
-function isJavaScriptUrl(url) {
-    return typeof url === 'string' && url.toLowerCase().startsWith(JAVASCRIPT_URL_PROTOCOL);
-}
 const jsWrapperStart = 'function a(){';
 const jsWrapperEnd = '}a();';
-function minifyJavaScriptUrl(node, attrName, terser) {
-    var _node_attrs;
-    if (!terser) return Promise.resolve();
-    let result = (_node_attrs = node.attrs) == null ? void 0 : _node_attrs[attrName];
-    if (result) {
-        result = jsWrapperStart + result.slice(JAVASCRIPT_URL_PROTOCOL.length) + jsWrapperEnd;
-        return terser.minify(result, {}) // Default Option is good enough
-        .then(({ code })=>{
-            const minifiedJs = code.substring(jsWrapperStart.length, code.length - jsWrapperEnd.length);
-            node.attrs[attrName] = JAVASCRIPT_URL_PROTOCOL + minifiedJs;
-        });
+const javascriptUrlRegex = /^(\s*)(javascript:)([\s\S]*)$/i;
+function getJavaScriptUrlMatch(url) {
+    const match = javascriptUrlRegex.exec(url);
+    if (!match) return null;
+    return {
+        leadingWhitespace: match[1],
+        code: match[3]
+    };
+}
+function getUrlScheme(value) {
+    const match = /^[a-z][a-z0-9+.-]*:/i.exec(value);
+    if (!match) return null;
+    return match[0].slice(0, -1).toLowerCase();
+}
+function shouldRelateUrlValue(value) {
+    const trimmed = value.trim();
+    if (!trimmed) return false;
+    if (trimmed.startsWith('#') || trimmed.startsWith('?')) return false;
+    const scheme = getUrlScheme(trimmed);
+    if (scheme) return scheme === 'http' || scheme === 'https';
+    return true;
+}
+function relateUrlValue(relateUrl, value) {
+    if (!shouldRelateUrlValue(value)) return value;
+    // FIXME!
+    // relateurl@1.0.0-alpha only supports URL while stable version (0.2.7) only supports string
+    // the WHATWG URL API is very strict while attrValue might not be a valid URL
+    // new URL should be used, and relateUrl#relate should be wrapped in try...catch after relateurl@1 is stable
+    try {
+        return relateUrl.relate(value);
+    } catch (unused) {
+        return value;
     }
-    return Promise.resolve();
+}
+function minifyJavaScriptUrl(node, attrName, match, terser) {
+    if (!terser) return Promise.resolve();
+    const result = jsWrapperStart + match.code + jsWrapperEnd;
+    return terser.minify(result, {}) // Default Option is good enough
+    .then(({ code })=>{
+        if (!code) return;
+        const minifiedJs = code.substring(jsWrapperStart.length, code.length - jsWrapperEnd.length);
+        node.attrs[attrName] = match.leadingWhitespace + JAVASCRIPT_URL_PROTOCOL + minifiedJs;
+    }).catch(()=>undefined);
 }
 
 export { mod as default };

package/dist/_modules/normalizeAttributeValues.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/normalizeAttributeValues.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';
 }