htmlnano 3.0.0 → 3.2.0

package/dist/_modules/minifyJs.js

@@ -26,20 +26,25 @@ var removeRedundantAttributes_js = require('./removeRedundantAttributes.js');
                 return node;
             }
             if (node.tag && node.tag === 'script') {
-                const mimeType = nodeAttrs.type || 'text/javascript';
+                const rawMimeType = typeof nodeAttrs.type === 'string' ? helpers_js.normalizeMimeType(nodeAttrs.type) : undefined;
+                const mimeType = rawMimeType || 'text/javascript';
                 if (removeRedundantAttributes_js.redundantScriptTypes.has(mimeType) || mimeType === 'module') {
-                    p = processScriptNode(node, terserOptions, terser);
+                    const scriptTerserOptions = resolveScriptTerserOptions(terserOptions, mimeType);
+                    p = processScriptNode(node, scriptTerserOptions, terser);
                     if (p) {
                         promises.push(p);
                     }
                 }
             }
             if (node.attrs) {
-                promises.push.apply(processNodeWithOnAttrs(node, terserOptions, terser));
+                promises.push(...processNodeWithOnAttrs(node, terserOptions, terser));
             }
             return node;
         });
-        return Promise.all(promises).then(()=>tree);
+        return Promise.all(promises).then(()=>{
+            applySmartQuoteOptions(tree);
+            return tree;
+        });
     }
 };
 function stripCdata(js) {
@@ -50,6 +55,89 @@ function stripCdata(js) {
     const strippedJs = leftStrippedJs.replace(/\/\/\s*\]\]>/, '').replace(/\/\*\s*\]\]>\s*\*\//, '');
     return leftStrippedJs === strippedJs ? js : strippedJs;
 }
+function resolveScriptTerserOptions(terserOptions, mimeType) {
+    var _terserOptions_toplevel, _terserOptions_compress, _terserOptions_mangle;
+    if (mimeType !== 'module' || terserOptions.module !== undefined) {
+        return terserOptions;
+    }
+    return {
+        ...terserOptions,
+        module: true,
+        toplevel: (_terserOptions_toplevel = terserOptions.toplevel) != null ? _terserOptions_toplevel : false,
+        compress: (_terserOptions_compress = terserOptions.compress) != null ? _terserOptions_compress : false,
+        mangle: (_terserOptions_mangle = terserOptions.mangle) != null ? _terserOptions_mangle : false
+    };
+}
+function resolveOnAttrTerserOptions(terserOptions) {
+    const output = terserOptions.output;
+    const format = terserOptions.format;
+    const outputHasQuoteStyle = !!(output && typeof output === 'object' && 'quote_style' in output);
+    const formatHasQuoteStyle = !!(format && typeof format === 'object' && 'quote_style' in format);
+    if (outputHasQuoteStyle || formatHasQuoteStyle) {
+        return terserOptions;
+    }
+    const resolved = {
+        ...terserOptions
+    };
+    if (format && typeof format === 'object') {
+        resolved.format = {
+            ...format,
+            ['quote_style']: 3
+        };
+    }
+    if (output && typeof output === 'object') {
+        resolved.output = {
+            ...output,
+            ['quote_style']: 3
+        };
+    }
+    if (!format && !output) {
+        resolved.output = {
+            ['quote_style']: 3
+        };
+    }
+    return resolved;
+}
+function applySmartQuoteOptions(tree) {
+    var _tree, _options, _tree_options, _quoteStyle, _tree_options1, _replaceQuote;
+    const quoteState = analyzeTreeQuotes(tree);
+    if (!quoteState.needsSmartQuotes || quoteState.hasMixedQuotes) {
+        return;
+    }
+    (_options = (_tree = tree).options) != null ? _options : _tree.options = {};
+    (_quoteStyle = (_tree_options = tree.options).quoteStyle) != null ? _quoteStyle : _tree_options.quoteStyle = 0;
+    (_replaceQuote = (_tree_options1 = tree.options).replaceQuote) != null ? _replaceQuote : _tree_options1.replaceQuote = false;
+}
+function analyzeTreeQuotes(tree) {
+    let needsSmartQuotes = false;
+    let hasMixedQuotes = false;
+    tree.walk((node)=>{
+        if (!node || !node.attrs) {
+            return node;
+        }
+        for (const [attrName, attrValue] of Object.entries(node.attrs)){
+            if (typeof attrValue !== 'string') {
+                continue;
+            }
+            const hasDoubleQuote = attrValue.includes('"');
+            const hasSingleQuote = attrValue.includes('\'');
+            if (hasDoubleQuote && helpers_js.isEventHandler(attrName)) {
+                needsSmartQuotes = true;
+            }
+            if (hasDoubleQuote && hasSingleQuote) {
+                hasMixedQuotes = true;
+            }
+            if (needsSmartQuotes && hasMixedQuotes) {
+                return node;
+            }
+        }
+        return node;
+    });
+    return {
+        needsSmartQuotes,
+        hasMixedQuotes
+    };
+}
 function processScriptNode(scriptNode, terserOptions, terser) {
     let js = helpers_js.extractTextContentFromNode(scriptNode).trim();
     if (!js.length) {
@@ -81,6 +169,7 @@ function processScriptNode(scriptNode, terserOptions, terser) {
 function processNodeWithOnAttrs(node, terserOptions, terser) {
     const jsWrapperStart = 'a=function(){';
     const jsWrapperEnd = '};a();';
+    const onAttrTerserOptions = resolveOnAttrTerserOptions(terserOptions);
     const promises = [];
     if (!node.attrs) {
         return promises;
@@ -98,15 +187,27 @@ function processNodeWithOnAttrs(node, terserOptions, terser) {
         // Therefore the attribute's code should be wrapped inside function:
         // "function _(){return false;}"
         const wrappedJs = jsWrapperStart + node.attrs[attrName] + jsWrapperEnd;
-        const promise = terser.minify(wrappedJs, terserOptions).then(({ code })=>{
+        const promise = terser.minify(wrappedJs, onAttrTerserOptions).then(({ code })=>{
             if (code) {
                 const minifiedJs = code.substring(jsWrapperStart.length, code.length - jsWrapperEnd.length);
                 node.attrs[attrName] = minifiedJs;
             }
+        }).catch((error)=>{
+            // Skip invalid inline handler code and preserve the original value.
+            if (isTerserParseError(error)) {
+                return;
+            }
+            throw error;
         });
         promises.push(promise);
     }
     return promises;
 }
+function isTerserParseError(error) {
+    if (!(error instanceof Error)) {
+        return false;
+    }
+    return error.name === 'SyntaxError' || error.message.includes('JS_Parse_Error');
+}
 
 exports.default = mod;

package/dist/_modules/minifyJs.mjs

@@ -1,4 +1,4 @@
-import { optionalImport, extractTextContentFromNode, isEventHandler } from '../helpers.mjs';
+import { optionalImport, normalizeMimeType, isEventHandler, extractTextContentFromNode } from '../helpers.mjs';
 import { redundantScriptTypes } from './removeRedundantAttributes.mjs';
 
 /** Minify JS with Terser */ const mod = {
@@ -24,20 +24,25 @@ import { redundantScriptTypes } from './removeRedundantAttributes.mjs';
                 return node;
             }
             if (node.tag && node.tag === 'script') {
-                const mimeType = nodeAttrs.type || 'text/javascript';
+                const rawMimeType = typeof nodeAttrs.type === 'string' ? normalizeMimeType(nodeAttrs.type) : undefined;
+                const mimeType = rawMimeType || 'text/javascript';
                 if (redundantScriptTypes.has(mimeType) || mimeType === 'module') {
-                    p = processScriptNode(node, terserOptions, terser);
+                    const scriptTerserOptions = resolveScriptTerserOptions(terserOptions, mimeType);
+                    p = processScriptNode(node, scriptTerserOptions, terser);
                     if (p) {
                         promises.push(p);
                     }
                 }
             }
             if (node.attrs) {
-                promises.push.apply(processNodeWithOnAttrs(node, terserOptions, terser));
+                promises.push(...processNodeWithOnAttrs(node, terserOptions, terser));
             }
             return node;
         });
-        return Promise.all(promises).then(()=>tree);
+        return Promise.all(promises).then(()=>{
+            applySmartQuoteOptions(tree);
+            return tree;
+        });
     }
 };
 function stripCdata(js) {
@@ -48,6 +53,89 @@ function stripCdata(js) {
     const strippedJs = leftStrippedJs.replace(/\/\/\s*\]\]>/, '').replace(/\/\*\s*\]\]>\s*\*\//, '');
     return leftStrippedJs === strippedJs ? js : strippedJs;
 }
+function resolveScriptTerserOptions(terserOptions, mimeType) {
+    var _terserOptions_toplevel, _terserOptions_compress, _terserOptions_mangle;
+    if (mimeType !== 'module' || terserOptions.module !== undefined) {
+        return terserOptions;
+    }
+    return {
+        ...terserOptions,
+        module: true,
+        toplevel: (_terserOptions_toplevel = terserOptions.toplevel) != null ? _terserOptions_toplevel : false,
+        compress: (_terserOptions_compress = terserOptions.compress) != null ? _terserOptions_compress : false,
+        mangle: (_terserOptions_mangle = terserOptions.mangle) != null ? _terserOptions_mangle : false
+    };
+}
+function resolveOnAttrTerserOptions(terserOptions) {
+    const output = terserOptions.output;
+    const format = terserOptions.format;
+    const outputHasQuoteStyle = !!(output && typeof output === 'object' && 'quote_style' in output);
+    const formatHasQuoteStyle = !!(format && typeof format === 'object' && 'quote_style' in format);
+    if (outputHasQuoteStyle || formatHasQuoteStyle) {
+        return terserOptions;
+    }
+    const resolved = {
+        ...terserOptions
+    };
+    if (format && typeof format === 'object') {
+        resolved.format = {
+            ...format,
+            ['quote_style']: 3
+        };
+    }
+    if (output && typeof output === 'object') {
+        resolved.output = {
+            ...output,
+            ['quote_style']: 3
+        };
+    }
+    if (!format && !output) {
+        resolved.output = {
+            ['quote_style']: 3
+        };
+    }
+    return resolved;
+}
+function applySmartQuoteOptions(tree) {
+    var _tree, _options, _tree_options, _quoteStyle, _tree_options1, _replaceQuote;
+    const quoteState = analyzeTreeQuotes(tree);
+    if (!quoteState.needsSmartQuotes || quoteState.hasMixedQuotes) {
+        return;
+    }
+    (_options = (_tree = tree).options) != null ? _options : _tree.options = {};
+    (_quoteStyle = (_tree_options = tree.options).quoteStyle) != null ? _quoteStyle : _tree_options.quoteStyle = 0;
+    (_replaceQuote = (_tree_options1 = tree.options).replaceQuote) != null ? _replaceQuote : _tree_options1.replaceQuote = false;
+}
+function analyzeTreeQuotes(tree) {
+    let needsSmartQuotes = false;
+    let hasMixedQuotes = false;
+    tree.walk((node)=>{
+        if (!node || !node.attrs) {
+            return node;
+        }
+        for (const [attrName, attrValue] of Object.entries(node.attrs)){
+            if (typeof attrValue !== 'string') {
+                continue;
+            }
+            const hasDoubleQuote = attrValue.includes('"');
+            const hasSingleQuote = attrValue.includes('\'');
+            if (hasDoubleQuote && isEventHandler(attrName)) {
+                needsSmartQuotes = true;
+            }
+            if (hasDoubleQuote && hasSingleQuote) {
+                hasMixedQuotes = true;
+            }
+            if (needsSmartQuotes && hasMixedQuotes) {
+                return node;
+            }
+        }
+        return node;
+    });
+    return {
+        needsSmartQuotes,
+        hasMixedQuotes
+    };
+}
 function processScriptNode(scriptNode, terserOptions, terser) {
     let js = extractTextContentFromNode(scriptNode).trim();
     if (!js.length) {
@@ -79,6 +167,7 @@ function processScriptNode(scriptNode, terserOptions, terser) {
 function processNodeWithOnAttrs(node, terserOptions, terser) {
     const jsWrapperStart = 'a=function(){';
     const jsWrapperEnd = '};a();';
+    const onAttrTerserOptions = resolveOnAttrTerserOptions(terserOptions);
     const promises = [];
     if (!node.attrs) {
         return promises;
@@ -96,15 +185,27 @@ function processNodeWithOnAttrs(node, terserOptions, terser) {
         // Therefore the attribute's code should be wrapped inside function:
         // "function _(){return false;}"
         const wrappedJs = jsWrapperStart + node.attrs[attrName] + jsWrapperEnd;
-        const promise = terser.minify(wrappedJs, terserOptions).then(({ code })=>{
+        const promise = terser.minify(wrappedJs, onAttrTerserOptions).then(({ code })=>{
             if (code) {
                 const minifiedJs = code.substring(jsWrapperStart.length, code.length - jsWrapperEnd.length);
                 node.attrs[attrName] = minifiedJs;
             }
+        }).catch((error)=>{
+            // Skip invalid inline handler code and preserve the original value.
+            if (isTerserParseError(error)) {
+                return;
+            }
+            throw error;
         });
         promises.push(promise);
     }
     return promises;
 }
+function isTerserParseError(error) {
+    if (!(error instanceof Error)) {
+        return false;
+    }
+    return error.name === 'SyntaxError' || error.message.includes('JS_Parse_Error');
+}
 
 export { mod as default };

package/dist/_modules/minifyJson.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/minifyJson.d.ts

@@ -2,16 +2,24 @@ import PostHTML from 'posthtml';
 import { MinifyOptions } from 'terser';
 import { Options } from 'cssnano';
 import { Config } from 'svgo';
+import { UserDefinedOptions } from 'purgecss';
 
 type PostHTMLTreeLike = [PostHTML.Node] & PostHTML.NodeAPI & {
     options?: {
         quoteAllAttributes?: boolean | undefined;
+        quoteStyle?: 0 | 1 | 2 | undefined;
+        replaceQuote?: boolean | undefined;
     } | undefined;
     render(): string;
     render(node: PostHTML.Node | PostHTMLTreeLike, renderOptions?: any): string;
 };
 type MaybeArray<T> = T | Array<T>;
 type PostHTMLNodeLike = PostHTML.Node | string;
+type HtmlnanoTemplateRule = {
+    tag: string;
+    attrs?: Record<string, string | boolean | void>;
+};
+type MinifyHtmlTemplateOptions = boolean | HtmlnanoTemplateRule[];
 interface HtmlnanoOptions {
     skipConfigLoading?: boolean;
     configPath?: string;
@@ -27,17 +35,42 @@ interface HtmlnanoOptions {
     mergeStyles?: boolean;
     mergeScripts?: boolean;
     minifyCss?: Options | boolean;
+    minifyHtmlTemplate?: MinifyHtmlTemplateOptions;
     minifyConditionalComments?: boolean;
     minifyJs?: MinifyOptions | boolean;
     minifyJson?: boolean;
+    minifyAttributes?: boolean | {
+        metaContent?: boolean;
+        redundantWhitespaces?: 'safe' | 'agressive' | false;
+    };
     minifySvg?: Config | boolean;
     normalizeAttributeValues?: boolean;
-    removeAttributeQuotes?: boolean;
-    removeComments?: boolean | 'safe' | 'all' | RegExp | ((comment: string) => boolean);
+    removeAttributeQuotes?: boolean | {
+        force?: boolean;
+    };
+    removeComments?: boolean | RegExp | ((comment: string) => boolean) | string;
     removeEmptyAttributes?: boolean;
+    removeEmptyElements?: boolean | {
+        removeWithAttributes?: boolean;
+    };
     removeRedundantAttributes?: boolean;
     removeOptionalTags?: boolean;
-    removeUnusedCss?: boolean;
+    removeUnusedCss?: boolean | ({
+        tool: 'purgeCSS';
+    } & Omit<UserDefinedOptions, 'content' | 'css' | 'extractors'>) | {
+        banner?: boolean;
+        csspath?: string;
+        htmlroot?: string;
+        ignore?: (string | RegExp)[];
+        inject?: string;
+        jsdom?: object;
+        media?: string[];
+        report?: boolean;
+        strictSSL?: boolean;
+        timeout?: number;
+        uncssrc?: string;
+        userAgent?: string;
+    };
     sortAttributes?: boolean | 'alphabetical' | 'frequency';
     sortAttributesWithLists?: boolean | 'alphabetical' | 'frequency';
 }

package/dist/_modules/minifyJson.js

@@ -1,6 +1,8 @@
 Object.defineProperty(exports, '__esModule', { value: true });
 
-const rNodeAttrsTypeJson = /(\/|\+)json/;
+var helpers_js = require('../helpers.js');
+
+const rNodeAttrsTypeJson = /(?:\/|\+)json$/i;
 const mod = {
     onContent () {
         return (content, node)=>{
@@ -8,17 +10,12 @@ const mod = {
             if (node.attrs && 'integrity' in node.attrs) {
                 return content;
             }
-            if (node.attrs && node.attrs.type && rNodeAttrsTypeJson.test(node.attrs.type)) {
+            const nodeType = node.attrs && typeof node.attrs.type === 'string' ? helpers_js.normalizeMimeType(node.attrs.type) : undefined;
+            if (nodeType && rNodeAttrsTypeJson.test(nodeType)) {
                 try {
-                    // cast minified JSON to an array
-                    let jsonContent = '';
-                    for(let i = 0, len = content.length; i < len; i++){
-                        const item = content[i];
-                        if (typeof item === 'string') {
-                            jsonContent += item;
-                        } else {
-                            return content; // If any item is not a string, return original contents
-                        }
+                    const jsonContent = typeof content === 'string' ? content : Array.isArray(content) && content.every((item)=>typeof item === 'string') ? content.join('') : null;
+                    if (jsonContent === null) {
+                        return content;
                     }
                     return [
                         JSON.stringify(JSON.parse(jsonContent))

package/dist/_modules/minifyJson.mjs

@@ -1,4 +1,6 @@
-const rNodeAttrsTypeJson = /(\/|\+)json/;
+import { normalizeMimeType } from '../helpers.mjs';
+
+const rNodeAttrsTypeJson = /(?:\/|\+)json$/i;
 const mod = {
     onContent () {
         return (content, node)=>{
@@ -6,17 +8,12 @@ const mod = {
             if (node.attrs && 'integrity' in node.attrs) {
                 return content;
             }
-            if (node.attrs && node.attrs.type && rNodeAttrsTypeJson.test(node.attrs.type)) {
+            const nodeType = node.attrs && typeof node.attrs.type === 'string' ? normalizeMimeType(node.attrs.type) : undefined;
+            if (nodeType && rNodeAttrsTypeJson.test(nodeType)) {
                 try {
-                    // cast minified JSON to an array
-                    let jsonContent = '';
-                    for(let i = 0, len = content.length; i < len; i++){
-                        const item = content[i];
-                        if (typeof item === 'string') {
-                            jsonContent += item;
-                        } else {
-                            return content; // If any item is not a string, return original contents
-                        }
+                    const jsonContent = typeof content === 'string' ? content : Array.isArray(content) && content.every((item)=>typeof item === 'string') ? content.join('') : null;
+                    if (jsonContent === null) {
+                        return content;
                     }
                     return [
                         JSON.stringify(JSON.parse(jsonContent))

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