htmlnano 3.0.0 → 3.2.0

package/dist/_modules/removeOptionalTags.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/removeOptionalTags.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/removeOptionalTags.js

@@ -7,7 +7,8 @@ const bodyStartTagCantBeOmittedWithFirstChildTags = new Set([
     'meta',
     'link',
     'script',
-    'style'
+    'style',
+    'template'
 ]);
 const tbodyStartTagCantBeOmittedWithPrecededTags = new Set([
     'tbody',
@@ -70,32 +71,40 @@ function getNextNode(tree, currentNodeIndex, nonEmpty = false) {
     }
     return null;
 }
+function omitTag(node) {
+    const optionalTagNode = node;
+    optionalTagNode.optionalTagName = typeof node.tag === 'string' ? node.tag : undefined;
+    // @ts-expect-error -- deliberately set tag to false
+    node.tag = false;
+}
+function getNodeTagName(node) {
+    if (node.tag) return node.tag;
+    const optionalTagNode = node;
+    return optionalTagNode.optionalTagName || false;
+}
 function removeOptionalTags(tree) {
     tree.forEach((node, index)=>{
         if (typeof node === 'string') return node;
         if (!node.tag) return node;
         if (node.attrs && Object.keys(node.attrs).length) return node;
         // const prevNode = getPrevNode(tree, index);
-        const prevNonEmptyNode = getPrevNode(tree, index, true);
+        const prevNode = getPrevNode(tree, index);
         const nextNode = getNextNode(tree, index);
-        const nextNonEmptyNode = getNextNode(tree, index, true);
         const firstChildNode = getFirstChildTag(node, false);
-        const firstNonEmptyChildNode = getFirstChildTag(node);
         /**
          * An "html" element's start tag may be omitted if the first thing inside the "html" element is not a comment.
          * An "html" element's end tag may be omitted if the "html" element is not IMMEDIATELY followed by a comment.
          */ if (node.tag === 'html') {
             let isHtmlStartTagCanBeOmitted = true;
             let isHtmlEndTagCanBeOmitted = true;
-            if (typeof firstNonEmptyChildNode === 'string' && helpers_js.isComment(firstNonEmptyChildNode)) {
+            if (typeof firstChildNode === 'string' && helpers_js.isComment(firstChildNode)) {
                 isHtmlStartTagCanBeOmitted = false;
             }
-            if (typeof nextNonEmptyNode === 'string' && helpers_js.isComment(nextNonEmptyNode)) {
+            if (typeof nextNode === 'string' && helpers_js.isComment(nextNode)) {
                 isHtmlEndTagCanBeOmitted = false;
             }
             if (isHtmlStartTagCanBeOmitted && isHtmlEndTagCanBeOmitted) {
-                // @ts-expect-error -- deliberately set tag to false
-                node.tag = false;
+                omitTag(node);
             }
         }
         /**
@@ -104,15 +113,14 @@ function removeOptionalTags(tree) {
          */ if (node.tag === 'head') {
             let isHeadStartTagCanBeOmitted = false;
             let isHeadEndTagCanBeOmitted = true;
-            if (isEmptyNode(node) || firstNonEmptyChildNode && typeof firstNonEmptyChildNode === 'object' && firstNonEmptyChildNode.tag) {
+            if (isEmptyNode(node) || firstChildNode && typeof firstChildNode === 'object' && firstChildNode.tag) {
                 isHeadStartTagCanBeOmitted = true;
             }
-            if (nextNode && typeof nextNode === 'string' && startWithWhitespacePattern.test(nextNode) || nextNonEmptyNode && typeof nextNonEmptyNode === 'string' && helpers_js.isComment(nextNode)) {
+            if (nextNode && typeof nextNode === 'string' && (startWithWhitespacePattern.test(nextNode) || helpers_js.isComment(nextNode))) {
                 isHeadEndTagCanBeOmitted = false;
             }
             if (isHeadStartTagCanBeOmitted && isHeadEndTagCanBeOmitted) {
-                // @ts-expect-error -- deliberately set tag to false
-                node.tag = false;
+                omitTag(node);
             }
         }
         /**
@@ -121,18 +129,17 @@ function removeOptionalTags(tree) {
          */ if (node.tag === 'body') {
             let isBodyStartTagCanBeOmitted = true;
             let isBodyEndTagCanBeOmitted = true;
-            if (typeof firstChildNode === 'string' && startWithWhitespacePattern.test(firstChildNode) || typeof firstNonEmptyChildNode === 'string' && helpers_js.isComment(firstNonEmptyChildNode)) {
+            if (typeof firstChildNode === 'string' && startWithWhitespacePattern.test(firstChildNode) || typeof firstChildNode === 'string' && helpers_js.isComment(firstChildNode)) {
                 isBodyStartTagCanBeOmitted = false;
             }
-            if (firstNonEmptyChildNode && typeof firstNonEmptyChildNode === 'object' && firstNonEmptyChildNode.tag && bodyStartTagCantBeOmittedWithFirstChildTags.has(firstNonEmptyChildNode.tag)) {
+            if (firstChildNode && typeof firstChildNode === 'object' && firstChildNode.tag && bodyStartTagCantBeOmittedWithFirstChildTags.has(firstChildNode.tag)) {
                 isBodyStartTagCanBeOmitted = false;
             }
             if (nextNode && typeof nextNode === 'string' && helpers_js.isComment(nextNode)) {
                 isBodyEndTagCanBeOmitted = false;
             }
             if (isBodyStartTagCanBeOmitted && isBodyEndTagCanBeOmitted) {
-                // @ts-expect-error -- deliberately set tag to false
-                node.tag = false;
+                omitTag(node);
             }
         }
         /**
@@ -141,18 +148,17 @@ function removeOptionalTags(tree) {
          */ if (node.tag === 'colgroup') {
             let isColgroupStartTagCanBeOmitted = false;
             let isColgroupEndTagCanBeOmitted = true;
-            if (firstNonEmptyChildNode && typeof firstNonEmptyChildNode === 'object' && firstNonEmptyChildNode.tag && firstNonEmptyChildNode.tag === 'col') {
+            if (firstChildNode && typeof firstChildNode === 'object' && firstChildNode.tag && firstChildNode.tag === 'col') {
                 isColgroupStartTagCanBeOmitted = true;
             }
-            if (prevNonEmptyNode && typeof prevNonEmptyNode === 'object' && prevNonEmptyNode.tag && prevNonEmptyNode.tag === 'colgroup') {
+            if (prevNode && typeof prevNode === 'object' && getNodeTagName(prevNode) === 'colgroup') {
                 isColgroupStartTagCanBeOmitted = false;
             }
-            if (nextNode && typeof nextNode === 'string' && startWithWhitespacePattern.test(nextNode) || nextNonEmptyNode && typeof nextNonEmptyNode === 'string' && helpers_js.isComment(nextNonEmptyNode)) {
+            if (nextNode && typeof nextNode === 'string' && (startWithWhitespacePattern.test(nextNode) || helpers_js.isComment(nextNode))) {
                 isColgroupEndTagCanBeOmitted = false;
             }
             if (isColgroupStartTagCanBeOmitted && isColgroupEndTagCanBeOmitted) {
-                // @ts-expect-error -- deliberately set tag to false
-                node.tag = false;
+                omitTag(node);
             }
         }
         /**
@@ -161,18 +167,23 @@ function removeOptionalTags(tree) {
          */ if (node.tag === 'tbody') {
             let isTbodyStartTagCanBeOmitted = false;
             let isTbodyEndTagCanBeOmitted = true;
-            if (firstNonEmptyChildNode && typeof firstNonEmptyChildNode === 'object' && firstNonEmptyChildNode.tag && firstNonEmptyChildNode.tag === 'tr') {
+            if (firstChildNode && typeof firstChildNode === 'object' && firstChildNode.tag && firstChildNode.tag === 'tr') {
                 isTbodyStartTagCanBeOmitted = true;
             }
-            if (prevNonEmptyNode && typeof prevNonEmptyNode === 'object' && prevNonEmptyNode.tag && tbodyStartTagCantBeOmittedWithPrecededTags.has(prevNonEmptyNode.tag)) {
-                isTbodyStartTagCanBeOmitted = false;
+            if (prevNode && typeof prevNode === 'object') {
+                const prevTagName = getNodeTagName(prevNode);
+                if (prevTagName && tbodyStartTagCantBeOmittedWithPrecededTags.has(prevTagName)) {
+                    isTbodyStartTagCanBeOmitted = false;
+                }
             }
-            if (nextNonEmptyNode && typeof nextNonEmptyNode === 'object' && nextNonEmptyNode.tag && tbodyEndTagCantBeOmittedWithFollowedTags.has(nextNonEmptyNode.tag)) {
-                isTbodyEndTagCanBeOmitted = false;
+            if (nextNode && typeof nextNode === 'object') {
+                const nextTagName = getNodeTagName(nextNode);
+                if (nextTagName && tbodyEndTagCantBeOmittedWithFollowedTags.has(nextTagName)) {
+                    isTbodyEndTagCanBeOmitted = false;
+                }
             }
             if (isTbodyStartTagCanBeOmitted && isTbodyEndTagCanBeOmitted) {
-                // @ts-expect-error -- deliberately set tag to false
-                node.tag = false;
+                omitTag(node);
             }
         }
         if (node.content && node.content.length) {

package/dist/_modules/removeOptionalTags.mjs

@@ -5,7 +5,8 @@ const bodyStartTagCantBeOmittedWithFirstChildTags = new Set([
     'meta',
     'link',
     'script',
-    'style'
+    'style',
+    'template'
 ]);
 const tbodyStartTagCantBeOmittedWithPrecededTags = new Set([
     'tbody',
@@ -68,32 +69,40 @@ function getNextNode(tree, currentNodeIndex, nonEmpty = false) {
     }
     return null;
 }
+function omitTag(node) {
+    const optionalTagNode = node;
+    optionalTagNode.optionalTagName = typeof node.tag === 'string' ? node.tag : undefined;
+    // @ts-expect-error -- deliberately set tag to false
+    node.tag = false;
+}
+function getNodeTagName(node) {
+    if (node.tag) return node.tag;
+    const optionalTagNode = node;
+    return optionalTagNode.optionalTagName || false;
+}
 function removeOptionalTags(tree) {
     tree.forEach((node, index)=>{
         if (typeof node === 'string') return node;
         if (!node.tag) return node;
         if (node.attrs && Object.keys(node.attrs).length) return node;
         // const prevNode = getPrevNode(tree, index);
-        const prevNonEmptyNode = getPrevNode(tree, index, true);
+        const prevNode = getPrevNode(tree, index);
         const nextNode = getNextNode(tree, index);
-        const nextNonEmptyNode = getNextNode(tree, index, true);
         const firstChildNode = getFirstChildTag(node, false);
-        const firstNonEmptyChildNode = getFirstChildTag(node);
         /**
          * An "html" element's start tag may be omitted if the first thing inside the "html" element is not a comment.
          * An "html" element's end tag may be omitted if the "html" element is not IMMEDIATELY followed by a comment.
          */ if (node.tag === 'html') {
             let isHtmlStartTagCanBeOmitted = true;
             let isHtmlEndTagCanBeOmitted = true;
-            if (typeof firstNonEmptyChildNode === 'string' && isComment(firstNonEmptyChildNode)) {
+            if (typeof firstChildNode === 'string' && isComment(firstChildNode)) {
                 isHtmlStartTagCanBeOmitted = false;
             }
-            if (typeof nextNonEmptyNode === 'string' && isComment(nextNonEmptyNode)) {
+            if (typeof nextNode === 'string' && isComment(nextNode)) {
                 isHtmlEndTagCanBeOmitted = false;
             }
             if (isHtmlStartTagCanBeOmitted && isHtmlEndTagCanBeOmitted) {
-                // @ts-expect-error -- deliberately set tag to false
-                node.tag = false;
+                omitTag(node);
             }
         }
         /**
@@ -102,15 +111,14 @@ function removeOptionalTags(tree) {
          */ if (node.tag === 'head') {
             let isHeadStartTagCanBeOmitted = false;
             let isHeadEndTagCanBeOmitted = true;
-            if (isEmptyNode(node) || firstNonEmptyChildNode && typeof firstNonEmptyChildNode === 'object' && firstNonEmptyChildNode.tag) {
+            if (isEmptyNode(node) || firstChildNode && typeof firstChildNode === 'object' && firstChildNode.tag) {
                 isHeadStartTagCanBeOmitted = true;
             }
-            if (nextNode && typeof nextNode === 'string' && startWithWhitespacePattern.test(nextNode) || nextNonEmptyNode && typeof nextNonEmptyNode === 'string' && isComment(nextNode)) {
+            if (nextNode && typeof nextNode === 'string' && (startWithWhitespacePattern.test(nextNode) || isComment(nextNode))) {
                 isHeadEndTagCanBeOmitted = false;
             }
             if (isHeadStartTagCanBeOmitted && isHeadEndTagCanBeOmitted) {
-                // @ts-expect-error -- deliberately set tag to false
-                node.tag = false;
+                omitTag(node);
             }
         }
         /**
@@ -119,18 +127,17 @@ function removeOptionalTags(tree) {
          */ if (node.tag === 'body') {
             let isBodyStartTagCanBeOmitted = true;
             let isBodyEndTagCanBeOmitted = true;
-            if (typeof firstChildNode === 'string' && startWithWhitespacePattern.test(firstChildNode) || typeof firstNonEmptyChildNode === 'string' && isComment(firstNonEmptyChildNode)) {
+            if (typeof firstChildNode === 'string' && startWithWhitespacePattern.test(firstChildNode) || typeof firstChildNode === 'string' && isComment(firstChildNode)) {
                 isBodyStartTagCanBeOmitted = false;
             }
-            if (firstNonEmptyChildNode && typeof firstNonEmptyChildNode === 'object' && firstNonEmptyChildNode.tag && bodyStartTagCantBeOmittedWithFirstChildTags.has(firstNonEmptyChildNode.tag)) {
+            if (firstChildNode && typeof firstChildNode === 'object' && firstChildNode.tag && bodyStartTagCantBeOmittedWithFirstChildTags.has(firstChildNode.tag)) {
                 isBodyStartTagCanBeOmitted = false;
             }
             if (nextNode && typeof nextNode === 'string' && isComment(nextNode)) {
                 isBodyEndTagCanBeOmitted = false;
             }
             if (isBodyStartTagCanBeOmitted && isBodyEndTagCanBeOmitted) {
-                // @ts-expect-error -- deliberately set tag to false
-                node.tag = false;
+                omitTag(node);
             }
         }
         /**
@@ -139,18 +146,17 @@ function removeOptionalTags(tree) {
          */ if (node.tag === 'colgroup') {
             let isColgroupStartTagCanBeOmitted = false;
             let isColgroupEndTagCanBeOmitted = true;
-            if (firstNonEmptyChildNode && typeof firstNonEmptyChildNode === 'object' && firstNonEmptyChildNode.tag && firstNonEmptyChildNode.tag === 'col') {
+            if (firstChildNode && typeof firstChildNode === 'object' && firstChildNode.tag && firstChildNode.tag === 'col') {
                 isColgroupStartTagCanBeOmitted = true;
             }
-            if (prevNonEmptyNode && typeof prevNonEmptyNode === 'object' && prevNonEmptyNode.tag && prevNonEmptyNode.tag === 'colgroup') {
+            if (prevNode && typeof prevNode === 'object' && getNodeTagName(prevNode) === 'colgroup') {
                 isColgroupStartTagCanBeOmitted = false;
             }
-            if (nextNode && typeof nextNode === 'string' && startWithWhitespacePattern.test(nextNode) || nextNonEmptyNode && typeof nextNonEmptyNode === 'string' && isComment(nextNonEmptyNode)) {
+            if (nextNode && typeof nextNode === 'string' && (startWithWhitespacePattern.test(nextNode) || isComment(nextNode))) {
                 isColgroupEndTagCanBeOmitted = false;
             }
             if (isColgroupStartTagCanBeOmitted && isColgroupEndTagCanBeOmitted) {
-                // @ts-expect-error -- deliberately set tag to false
-                node.tag = false;
+                omitTag(node);
             }
         }
         /**
@@ -159,18 +165,23 @@ function removeOptionalTags(tree) {
          */ if (node.tag === 'tbody') {
             let isTbodyStartTagCanBeOmitted = false;
             let isTbodyEndTagCanBeOmitted = true;
-            if (firstNonEmptyChildNode && typeof firstNonEmptyChildNode === 'object' && firstNonEmptyChildNode.tag && firstNonEmptyChildNode.tag === 'tr') {
+            if (firstChildNode && typeof firstChildNode === 'object' && firstChildNode.tag && firstChildNode.tag === 'tr') {
                 isTbodyStartTagCanBeOmitted = true;
             }
-            if (prevNonEmptyNode && typeof prevNonEmptyNode === 'object' && prevNonEmptyNode.tag && tbodyStartTagCantBeOmittedWithPrecededTags.has(prevNonEmptyNode.tag)) {
-                isTbodyStartTagCanBeOmitted = false;
+            if (prevNode && typeof prevNode === 'object') {
+                const prevTagName = getNodeTagName(prevNode);
+                if (prevTagName && tbodyStartTagCantBeOmittedWithPrecededTags.has(prevTagName)) {
+                    isTbodyStartTagCanBeOmitted = false;
+                }
             }
-            if (nextNonEmptyNode && typeof nextNonEmptyNode === 'object' && nextNonEmptyNode.tag && tbodyEndTagCantBeOmittedWithFollowedTags.has(nextNonEmptyNode.tag)) {
-                isTbodyEndTagCanBeOmitted = false;
+            if (nextNode && typeof nextNode === 'object') {
+                const nextTagName = getNodeTagName(nextNode);
+                if (nextTagName && tbodyEndTagCantBeOmittedWithFollowedTags.has(nextTagName)) {
+                    isTbodyEndTagCanBeOmitted = false;
+                }
             }
             if (isTbodyStartTagCanBeOmitted && isTbodyEndTagCanBeOmitted) {
-                // @ts-expect-error -- deliberately set tag to false
-                node.tag = false;
+                omitTag(node);
             }
         }
         if (node.content && node.content.length) {

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