htmlnano 3.2.0 → 3.2.1

package/dist/_modules/minifyCss.d.mts

@@ -1,25 +1,71 @@
 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 & {
+type PostHTMLNodeLike = PostHTML.Node | string;
+type PostHTMLTreeLike = [PostHTMLNodeLike] & 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;
+    render(node: PostHTMLNodeLike | 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[];
+type HtmlnanoMinifyCssOptions = object;
+type HtmlnanoMinifyJsOptions = object;
+type HtmlnanoMinifySvgOptions = object;
+type HtmlnanoPurgeCssPattern = string | RegExp;
+type HtmlnanoPurgeCssExtractorResultDetailed = {
+    attributes: {
+        names: string[];
+        values: string[];
+    };
+    classes: string[];
+    ids: string[];
+    tags: string[];
+    undetermined: string[];
+};
+type HtmlnanoPurgeCssExtractorResult = HtmlnanoPurgeCssExtractorResultDetailed | string[];
+type HtmlnanoPurgeCssDefaultExtractor = (content: string) => HtmlnanoPurgeCssExtractorResult;
+type HtmlnanoPurgeCssSourceMapOptions = {
+    absolute?: boolean;
+    annotation?: boolean | string;
+    from?: string;
+    inline?: boolean;
+    prev?: boolean | object | string;
+    sourcesContent?: boolean;
+    to?: string;
+};
+type HtmlnanoPurgeCssSafelist = HtmlnanoPurgeCssPattern[] | {
+    standard?: HtmlnanoPurgeCssPattern[];
+    deep?: RegExp[];
+    greedy?: RegExp[];
+    variables?: HtmlnanoPurgeCssPattern[];
+    keyframes?: HtmlnanoPurgeCssPattern[];
+};
+interface HtmlnanoPurgeCssOptions {
+    tool: 'purgeCSS';
+    defaultExtractor?: HtmlnanoPurgeCssDefaultExtractor;
+    fontFace?: boolean;
+    keyframes?: boolean;
+    output?: string;
+    rejected?: boolean;
+    rejectedCss?: boolean;
+    sourceMap?: boolean | HtmlnanoPurgeCssSourceMapOptions;
+    stdin?: boolean;
+    stdout?: boolean;
+    variables?: boolean;
+    safelist?: HtmlnanoPurgeCssSafelist;
+    blocklist?: HtmlnanoPurgeCssPattern[];
+    skippedContentGlobs?: string[];
+    dynamicAttributes?: string[];
+}
 interface HtmlnanoOptions {
     skipConfigLoading?: boolean;
     configPath?: string;
@@ -34,16 +80,16 @@ interface HtmlnanoOptions {
     minifyUrls?: URL | string | false;
     mergeStyles?: boolean;
     mergeScripts?: boolean;
-    minifyCss?: Options | boolean;
+    minifyCss?: HtmlnanoMinifyCssOptions | boolean;
     minifyHtmlTemplate?: MinifyHtmlTemplateOptions;
     minifyConditionalComments?: boolean;
-    minifyJs?: MinifyOptions | boolean;
+    minifyJs?: HtmlnanoMinifyJsOptions | boolean;
     minifyJson?: boolean;
     minifyAttributes?: boolean | {
         metaContent?: boolean;
         redundantWhitespaces?: 'safe' | 'agressive' | false;
     };
-    minifySvg?: Config | boolean;
+    minifySvg?: HtmlnanoMinifySvgOptions | boolean;
     normalizeAttributeValues?: boolean;
     removeAttributeQuotes?: boolean | {
         force?: boolean;
@@ -55,9 +101,8 @@ interface HtmlnanoOptions {
     };
     removeRedundantAttributes?: boolean;
     removeOptionalTags?: boolean;
-    removeUnusedCss?: boolean | ({
-        tool: 'purgeCSS';
-    } & Omit<UserDefinedOptions, 'content' | 'css' | 'extractors'>) | {
+    removeUnusedCss?: boolean | HtmlnanoPurgeCssOptions | {
+        tool?: 'uncss';
         banner?: boolean;
         csspath?: string;
         htmlroot?: string;
@@ -77,7 +122,7 @@ interface HtmlnanoOptions {
 type HtmlnanoModuleAttrsHandler = (attrs: Record<string, string | boolean | void>, node: PostHTML.Node) => Record<string, string | boolean | void>;
 type HtmlnanoModuleContentHandler = (content: Array<PostHTMLNodeLike>, node: PostHTML.Node) => MaybeArray<PostHTMLNodeLike>;
 type HtmlnanoModuleNodeHandler = (node: PostHTMLNodeLike) => PostHTML.Node | string;
-type OptionalOptions<T> = T extends boolean | string | Function | number | null | undefined ? T : T extends object ? Partial<T> : T;
+type OptionalOptions<T> = T extends boolean | string | Function | number | null | undefined ? T : T extends Array<infer Item> ? Array<Item> : T extends object ? Partial<T> : T;
 type HtmlnanoModule<Options = any> = {
     onAttrs?: (options: Partial<HtmlnanoOptions>, moduleOptions: OptionalOptions<Options>) => HtmlnanoModuleAttrsHandler;
     onContent?: (options: Partial<HtmlnanoOptions>, moduleOptions: OptionalOptions<Options>) => HtmlnanoModuleContentHandler;
@@ -87,4 +132,6 @@ type HtmlnanoModule<Options = any> = {
 
 declare const mod: HtmlnanoModule<Options>;
 
-export { mod as default };
+declare function getInlineCssnanoOptions(cssnanoOptions: Options | undefined): Options | undefined;
+
+export { mod as default, getInlineCssnanoOptions };

package/dist/_modules/minifyCss.d.ts

@@ -1,25 +1,71 @@
 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 & {
+type PostHTMLNodeLike = PostHTML.Node | string;
+type PostHTMLTreeLike = [PostHTMLNodeLike] & 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;
+    render(node: PostHTMLNodeLike | 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[];
+type HtmlnanoMinifyCssOptions = object;
+type HtmlnanoMinifyJsOptions = object;
+type HtmlnanoMinifySvgOptions = object;
+type HtmlnanoPurgeCssPattern = string | RegExp;
+type HtmlnanoPurgeCssExtractorResultDetailed = {
+    attributes: {
+        names: string[];
+        values: string[];
+    };
+    classes: string[];
+    ids: string[];
+    tags: string[];
+    undetermined: string[];
+};
+type HtmlnanoPurgeCssExtractorResult = HtmlnanoPurgeCssExtractorResultDetailed | string[];
+type HtmlnanoPurgeCssDefaultExtractor = (content: string) => HtmlnanoPurgeCssExtractorResult;
+type HtmlnanoPurgeCssSourceMapOptions = {
+    absolute?: boolean;
+    annotation?: boolean | string;
+    from?: string;
+    inline?: boolean;
+    prev?: boolean | object | string;
+    sourcesContent?: boolean;
+    to?: string;
+};
+type HtmlnanoPurgeCssSafelist = HtmlnanoPurgeCssPattern[] | {
+    standard?: HtmlnanoPurgeCssPattern[];
+    deep?: RegExp[];
+    greedy?: RegExp[];
+    variables?: HtmlnanoPurgeCssPattern[];
+    keyframes?: HtmlnanoPurgeCssPattern[];
+};
+interface HtmlnanoPurgeCssOptions {
+    tool: 'purgeCSS';
+    defaultExtractor?: HtmlnanoPurgeCssDefaultExtractor;
+    fontFace?: boolean;
+    keyframes?: boolean;
+    output?: string;
+    rejected?: boolean;
+    rejectedCss?: boolean;
+    sourceMap?: boolean | HtmlnanoPurgeCssSourceMapOptions;
+    stdin?: boolean;
+    stdout?: boolean;
+    variables?: boolean;
+    safelist?: HtmlnanoPurgeCssSafelist;
+    blocklist?: HtmlnanoPurgeCssPattern[];
+    skippedContentGlobs?: string[];
+    dynamicAttributes?: string[];
+}
 interface HtmlnanoOptions {
     skipConfigLoading?: boolean;
     configPath?: string;
@@ -34,16 +80,16 @@ interface HtmlnanoOptions {
     minifyUrls?: URL | string | false;
     mergeStyles?: boolean;
     mergeScripts?: boolean;
-    minifyCss?: Options | boolean;
+    minifyCss?: HtmlnanoMinifyCssOptions | boolean;
     minifyHtmlTemplate?: MinifyHtmlTemplateOptions;
     minifyConditionalComments?: boolean;
-    minifyJs?: MinifyOptions | boolean;
+    minifyJs?: HtmlnanoMinifyJsOptions | boolean;
     minifyJson?: boolean;
     minifyAttributes?: boolean | {
         metaContent?: boolean;
         redundantWhitespaces?: 'safe' | 'agressive' | false;
     };
-    minifySvg?: Config | boolean;
+    minifySvg?: HtmlnanoMinifySvgOptions | boolean;
     normalizeAttributeValues?: boolean;
     removeAttributeQuotes?: boolean | {
         force?: boolean;
@@ -55,9 +101,8 @@ interface HtmlnanoOptions {
     };
     removeRedundantAttributes?: boolean;
     removeOptionalTags?: boolean;
-    removeUnusedCss?: boolean | ({
-        tool: 'purgeCSS';
-    } & Omit<UserDefinedOptions, 'content' | 'css' | 'extractors'>) | {
+    removeUnusedCss?: boolean | HtmlnanoPurgeCssOptions | {
+        tool?: 'uncss';
         banner?: boolean;
         csspath?: string;
         htmlroot?: string;
@@ -77,7 +122,7 @@ interface HtmlnanoOptions {
 type HtmlnanoModuleAttrsHandler = (attrs: Record<string, string | boolean | void>, node: PostHTML.Node) => Record<string, string | boolean | void>;
 type HtmlnanoModuleContentHandler = (content: Array<PostHTMLNodeLike>, node: PostHTML.Node) => MaybeArray<PostHTMLNodeLike>;
 type HtmlnanoModuleNodeHandler = (node: PostHTMLNodeLike) => PostHTML.Node | string;
-type OptionalOptions<T> = T extends boolean | string | Function | number | null | undefined ? T : T extends object ? Partial<T> : T;
+type OptionalOptions<T> = T extends boolean | string | Function | number | null | undefined ? T : T extends Array<infer Item> ? Array<Item> : T extends object ? Partial<T> : T;
 type HtmlnanoModule<Options = any> = {
     onAttrs?: (options: Partial<HtmlnanoOptions>, moduleOptions: OptionalOptions<Options>) => HtmlnanoModuleAttrsHandler;
     onContent?: (options: Partial<HtmlnanoOptions>, moduleOptions: OptionalOptions<Options>) => HtmlnanoModuleContentHandler;
@@ -87,4 +132,6 @@ type HtmlnanoModule<Options = any> = {
 
 declare const mod: HtmlnanoModule<Options>;
 
-export { mod as default };
+declare function getInlineCssnanoOptions(cssnanoOptions: Options | undefined): Options | undefined;
+
+export { mod as default, getInlineCssnanoOptions };

package/dist/_modules/minifyCss.js

@@ -8,6 +8,14 @@ const postcssOptions = {
     // > Set it to CSS file path or to `undefined` to prevent this warning.
     from: undefined
 };
+const inlineCssExcludedPlugins = {
+    mergeRules: false,
+    minifySelectors: false,
+    minifyParams: false,
+    normalizeCharset: false,
+    uniqueSelectors: false,
+    normalizeUnicode: false
+};
 /** Minify CSS with cssnano */ const mod = {
     async default (tree, _, cssnanoOptions) {
         const cssnano = await helpers_js.optionalImport('cssnano');
@@ -15,6 +23,9 @@ const postcssOptions = {
         if (!cssnano || !postcss) {
             return tree;
         }
+        const processor = createCssProcessor(postcss, cssnano, cssnanoOptions);
+        const inlineStyleProcessor = createCssProcessor(postcss, cssnano, getInlineCssnanoOptions(cssnanoOptions));
+        const minifiedCssCache = new Map();
         const promises = [];
         let p;
         tree.walk((node)=>{
@@ -23,12 +34,12 @@ const postcssOptions = {
                 return node;
             }
             if (helpers_js.isStyleNode(node) && helpers_js.isCssStyleType(node)) {
-                p = processStyleNode(node, cssnanoOptions, cssnano, postcss);
+                p = processStyleNode(node, processor, minifiedCssCache);
                 if (p) {
                     promises.push(p);
                 }
             } else if (node.attrs && node.attrs.style) {
-                p = processStyleAttr(node, cssnanoOptions, cssnano, postcss);
+                p = processStyleAttr(node, inlineStyleProcessor, minifiedCssCache);
                 if (p) {
                     promises.push(p);
                 }
@@ -38,22 +49,69 @@ const postcssOptions = {
         return Promise.all(promises).then(()=>tree);
     }
 };
-function processStyleNode(styleNode, cssnanoOptions, cssnano, postcss) {
+function createCssProcessor(postcss, cssnano, cssnanoOptions) {
+    return postcss([
+        cssnano(cssnanoOptions)
+    ]);
+}
+function getInlineCssnanoOptions(cssnanoOptions) {
+    if (!cssnanoOptions || typeof cssnanoOptions !== 'object') {
+        return {
+            preset: [
+                'default',
+                inlineCssExcludedPlugins
+            ]
+        };
+    }
+    if (Array.isArray(cssnanoOptions.plugins)) {
+        return cssnanoOptions;
+    }
+    if (!('preset' in cssnanoOptions) || cssnanoOptions.preset === undefined) {
+        return {
+            ...cssnanoOptions,
+            preset: [
+                'default',
+                inlineCssExcludedPlugins
+            ]
+        };
+    }
+    if (cssnanoOptions.preset === 'default') {
+        return {
+            ...cssnanoOptions,
+            preset: [
+                'default',
+                inlineCssExcludedPlugins
+            ]
+        };
+    }
+    if (Array.isArray(cssnanoOptions.preset) && cssnanoOptions.preset[0] === 'default') {
+        const presetOptions = cssnanoOptions.preset[1];
+        return {
+            ...cssnanoOptions,
+            preset: [
+                'default',
+                {
+                    ...inlineCssExcludedPlugins,
+                    ...presetOptions && typeof presetOptions === 'object' ? presetOptions : {}
+                }
+            ]
+        };
+    }
+    return cssnanoOptions;
+}
+function processStyleNode(styleNode, processor, minifiedCssCache) {
     let css = helpers_js.extractCssFromStyleNode(styleNode);
     if (!css || css.trim() === '') return;
     // Improve performance by avoiding calling stripCssCdata again and again
     const { strippedCss, isCdataWrapped } = helpers_js.stripCssCdata(css);
     css = strippedCss;
-    return postcss([
-        cssnano(cssnanoOptions)
-    ]).process(css, postcssOptions).then((result)=>{
-        const minifiedCss = isCdataWrapped ? result.toString() : result.css;
+    return processCss(processor, minifiedCssCache, `${isCdataWrapped ? 'style-cdata:' : 'style:'}${css}`, css, isCdataWrapped).then((minifiedCss)=>{
         styleNode.content = [
             helpers_js.wrapCssCdata(minifiedCss, isCdataWrapped)
         ];
     });
 }
-function processStyleAttr(node, cssnanoOptions, cssnano, postcss) {
+function processStyleAttr(node, processor, minifiedCssCache) {
     // CSS "color: red;" is invalid. Therefore it should be wrapped inside some selector:
     // a{color: red;}
     const wrapperStart = 'a{';
@@ -65,13 +123,22 @@ function processStyleAttr(node, cssnanoOptions, cssnano, postcss) {
         return;
     }
     const wrappedStyle = wrapperStart + (node.attrs.style || '') + wrapperEnd;
-    return postcss([
-        cssnano(cssnanoOptions)
-    ]).process(wrappedStyle, postcssOptions).then((result)=>{
-        const minifiedCss = result.css;
+    return processCss(processor, minifiedCssCache, `attr:${wrappedStyle}`, wrappedStyle).then((minifiedCss)=>{
         // Remove wrapperStart at the start and wrapperEnd at the end of minifiedCss
         node.attrs.style = minifiedCss.substring(wrapperStart.length, minifiedCss.length - wrapperEnd.length);
     });
 }
+function processCss(processor, minifiedCssCache, cacheKey, css, useToString = false) {
+    let minifiedCss = minifiedCssCache.get(cacheKey);
+    if (!minifiedCss) {
+        minifiedCss = processor.process(css, postcssOptions).then((result)=>useToString ? result.toString() : result.css).catch((error)=>{
+            minifiedCssCache.delete(cacheKey);
+            throw error;
+        });
+        minifiedCssCache.set(cacheKey, minifiedCss);
+    }
+    return minifiedCss;
+}
 
 exports.default = mod;
+exports.getInlineCssnanoOptions = getInlineCssnanoOptions;

package/dist/_modules/minifyCss.mjs

@@ -6,6 +6,14 @@ const postcssOptions = {
     // > Set it to CSS file path or to `undefined` to prevent this warning.
     from: undefined
 };
+const inlineCssExcludedPlugins = {
+    mergeRules: false,
+    minifySelectors: false,
+    minifyParams: false,
+    normalizeCharset: false,
+    uniqueSelectors: false,
+    normalizeUnicode: false
+};
 /** Minify CSS with cssnano */ const mod = {
     async default (tree, _, cssnanoOptions) {
         const cssnano = await optionalImport('cssnano');
@@ -13,6 +21,9 @@ const postcssOptions = {
         if (!cssnano || !postcss) {
             return tree;
         }
+        const processor = createCssProcessor(postcss, cssnano, cssnanoOptions);
+        const inlineStyleProcessor = createCssProcessor(postcss, cssnano, getInlineCssnanoOptions(cssnanoOptions));
+        const minifiedCssCache = new Map();
         const promises = [];
         let p;
         tree.walk((node)=>{
@@ -21,12 +32,12 @@ const postcssOptions = {
                 return node;
             }
             if (isStyleNode(node) && isCssStyleType(node)) {
-                p = processStyleNode(node, cssnanoOptions, cssnano, postcss);
+                p = processStyleNode(node, processor, minifiedCssCache);
                 if (p) {
                     promises.push(p);
                 }
             } else if (node.attrs && node.attrs.style) {
-                p = processStyleAttr(node, cssnanoOptions, cssnano, postcss);
+                p = processStyleAttr(node, inlineStyleProcessor, minifiedCssCache);
                 if (p) {
                     promises.push(p);
                 }
@@ -36,22 +47,69 @@ const postcssOptions = {
         return Promise.all(promises).then(()=>tree);
     }
 };
-function processStyleNode(styleNode, cssnanoOptions, cssnano, postcss) {
+function createCssProcessor(postcss, cssnano, cssnanoOptions) {
+    return postcss([
+        cssnano(cssnanoOptions)
+    ]);
+}
+function getInlineCssnanoOptions(cssnanoOptions) {
+    if (!cssnanoOptions || typeof cssnanoOptions !== 'object') {
+        return {
+            preset: [
+                'default',
+                inlineCssExcludedPlugins
+            ]
+        };
+    }
+    if (Array.isArray(cssnanoOptions.plugins)) {
+        return cssnanoOptions;
+    }
+    if (!('preset' in cssnanoOptions) || cssnanoOptions.preset === undefined) {
+        return {
+            ...cssnanoOptions,
+            preset: [
+                'default',
+                inlineCssExcludedPlugins
+            ]
+        };
+    }
+    if (cssnanoOptions.preset === 'default') {
+        return {
+            ...cssnanoOptions,
+            preset: [
+                'default',
+                inlineCssExcludedPlugins
+            ]
+        };
+    }
+    if (Array.isArray(cssnanoOptions.preset) && cssnanoOptions.preset[0] === 'default') {
+        const presetOptions = cssnanoOptions.preset[1];
+        return {
+            ...cssnanoOptions,
+            preset: [
+                'default',
+                {
+                    ...inlineCssExcludedPlugins,
+                    ...presetOptions && typeof presetOptions === 'object' ? presetOptions : {}
+                }
+            ]
+        };
+    }
+    return cssnanoOptions;
+}
+function processStyleNode(styleNode, processor, minifiedCssCache) {
     let css = extractCssFromStyleNode(styleNode);
     if (!css || css.trim() === '') return;
     // Improve performance by avoiding calling stripCssCdata again and again
     const { strippedCss, isCdataWrapped } = stripCssCdata(css);
     css = strippedCss;
-    return postcss([
-        cssnano(cssnanoOptions)
-    ]).process(css, postcssOptions).then((result)=>{
-        const minifiedCss = isCdataWrapped ? result.toString() : result.css;
+    return processCss(processor, minifiedCssCache, `${isCdataWrapped ? 'style-cdata:' : 'style:'}${css}`, css, isCdataWrapped).then((minifiedCss)=>{
         styleNode.content = [
             wrapCssCdata(minifiedCss, isCdataWrapped)
         ];
     });
 }
-function processStyleAttr(node, cssnanoOptions, cssnano, postcss) {
+function processStyleAttr(node, processor, minifiedCssCache) {
     // CSS "color: red;" is invalid. Therefore it should be wrapped inside some selector:
     // a{color: red;}
     const wrapperStart = 'a{';
@@ -63,13 +121,21 @@ function processStyleAttr(node, cssnanoOptions, cssnano, postcss) {
         return;
     }
     const wrappedStyle = wrapperStart + (node.attrs.style || '') + wrapperEnd;
-    return postcss([
-        cssnano(cssnanoOptions)
-    ]).process(wrappedStyle, postcssOptions).then((result)=>{
-        const minifiedCss = result.css;
+    return processCss(processor, minifiedCssCache, `attr:${wrappedStyle}`, wrappedStyle).then((minifiedCss)=>{
         // Remove wrapperStart at the start and wrapperEnd at the end of minifiedCss
         node.attrs.style = minifiedCss.substring(wrapperStart.length, minifiedCss.length - wrapperEnd.length);
     });
 }
+function processCss(processor, minifiedCssCache, cacheKey, css, useToString = false) {
+    let minifiedCss = minifiedCssCache.get(cacheKey);
+    if (!minifiedCss) {
+        minifiedCss = processor.process(css, postcssOptions).then((result)=>useToString ? result.toString() : result.css).catch((error)=>{
+            minifiedCssCache.delete(cacheKey);
+            throw error;
+        });
+        minifiedCssCache.set(cacheKey, minifiedCss);
+    }
+    return minifiedCss;
+}
 
-export { mod as default };
+export { mod as default, getInlineCssnanoOptions };

package/dist/_modules/minifyHtmlTemplate.d.mts

@@ -1,25 +1,70 @@
 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 & {
+type PostHTMLNodeLike = PostHTML.Node | string;
+type PostHTMLTreeLike = [PostHTMLNodeLike] & 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;
+    render(node: PostHTMLNodeLike | 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[];
+type HtmlnanoMinifyCssOptions = object;
+type HtmlnanoMinifyJsOptions = object;
+type HtmlnanoMinifySvgOptions = object;
+type HtmlnanoPurgeCssPattern = string | RegExp;
+type HtmlnanoPurgeCssExtractorResultDetailed = {
+    attributes: {
+        names: string[];
+        values: string[];
+    };
+    classes: string[];
+    ids: string[];
+    tags: string[];
+    undetermined: string[];
+};
+type HtmlnanoPurgeCssExtractorResult = HtmlnanoPurgeCssExtractorResultDetailed | string[];
+type HtmlnanoPurgeCssDefaultExtractor = (content: string) => HtmlnanoPurgeCssExtractorResult;
+type HtmlnanoPurgeCssSourceMapOptions = {
+    absolute?: boolean;
+    annotation?: boolean | string;
+    from?: string;
+    inline?: boolean;
+    prev?: boolean | object | string;
+    sourcesContent?: boolean;
+    to?: string;
+};
+type HtmlnanoPurgeCssSafelist = HtmlnanoPurgeCssPattern[] | {
+    standard?: HtmlnanoPurgeCssPattern[];
+    deep?: RegExp[];
+    greedy?: RegExp[];
+    variables?: HtmlnanoPurgeCssPattern[];
+    keyframes?: HtmlnanoPurgeCssPattern[];
+};
+interface HtmlnanoPurgeCssOptions {
+    tool: 'purgeCSS';
+    defaultExtractor?: HtmlnanoPurgeCssDefaultExtractor;
+    fontFace?: boolean;
+    keyframes?: boolean;
+    output?: string;
+    rejected?: boolean;
+    rejectedCss?: boolean;
+    sourceMap?: boolean | HtmlnanoPurgeCssSourceMapOptions;
+    stdin?: boolean;
+    stdout?: boolean;
+    variables?: boolean;
+    safelist?: HtmlnanoPurgeCssSafelist;
+    blocklist?: HtmlnanoPurgeCssPattern[];
+    skippedContentGlobs?: string[];
+    dynamicAttributes?: string[];
+}
 interface HtmlnanoOptions {
     skipConfigLoading?: boolean;
     configPath?: string;
@@ -34,16 +79,16 @@ interface HtmlnanoOptions {
     minifyUrls?: URL | string | false;
     mergeStyles?: boolean;
     mergeScripts?: boolean;
-    minifyCss?: Options | boolean;
+    minifyCss?: HtmlnanoMinifyCssOptions | boolean;
     minifyHtmlTemplate?: MinifyHtmlTemplateOptions;
     minifyConditionalComments?: boolean;
-    minifyJs?: MinifyOptions | boolean;
+    minifyJs?: HtmlnanoMinifyJsOptions | boolean;
     minifyJson?: boolean;
     minifyAttributes?: boolean | {
         metaContent?: boolean;
         redundantWhitespaces?: 'safe' | 'agressive' | false;
     };
-    minifySvg?: Config | boolean;
+    minifySvg?: HtmlnanoMinifySvgOptions | boolean;
     normalizeAttributeValues?: boolean;
     removeAttributeQuotes?: boolean | {
         force?: boolean;
@@ -55,9 +100,8 @@ interface HtmlnanoOptions {
     };
     removeRedundantAttributes?: boolean;
     removeOptionalTags?: boolean;
-    removeUnusedCss?: boolean | ({
-        tool: 'purgeCSS';
-    } & Omit<UserDefinedOptions, 'content' | 'css' | 'extractors'>) | {
+    removeUnusedCss?: boolean | HtmlnanoPurgeCssOptions | {
+        tool?: 'uncss';
         banner?: boolean;
         csspath?: string;
         htmlroot?: string;
@@ -77,7 +121,7 @@ interface HtmlnanoOptions {
 type HtmlnanoModuleAttrsHandler = (attrs: Record<string, string | boolean | void>, node: PostHTML.Node) => Record<string, string | boolean | void>;
 type HtmlnanoModuleContentHandler = (content: Array<PostHTMLNodeLike>, node: PostHTML.Node) => MaybeArray<PostHTMLNodeLike>;
 type HtmlnanoModuleNodeHandler = (node: PostHTMLNodeLike) => PostHTML.Node | string;
-type OptionalOptions<T> = T extends boolean | string | Function | number | null | undefined ? T : T extends object ? Partial<T> : T;
+type OptionalOptions<T> = T extends boolean | string | Function | number | null | undefined ? T : T extends Array<infer Item> ? Array<Item> : T extends object ? Partial<T> : T;
 type HtmlnanoModule<Options = any> = {
     onAttrs?: (options: Partial<HtmlnanoOptions>, moduleOptions: OptionalOptions<Options>) => HtmlnanoModuleAttrsHandler;
     onContent?: (options: Partial<HtmlnanoOptions>, moduleOptions: OptionalOptions<Options>) => HtmlnanoModuleContentHandler;