htmlnano 3.0.0 → 3.2.0

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

@@ -22,7 +22,7 @@ const postcssOptions = {
             if (node.attrs && 'integrity' in node.attrs) {
                 return node;
             }
-            if (helpers_js.isStyleNode(node)) {
+            if (helpers_js.isStyleNode(node) && helpers_js.isCssStyleType(node)) {
                 p = processStyleNode(node, cssnanoOptions, cssnano, postcss);
                 if (p) {
                     promises.push(p);
@@ -40,26 +40,17 @@ const postcssOptions = {
 };
 function processStyleNode(styleNode, cssnanoOptions, cssnano, postcss) {
     let css = helpers_js.extractCssFromStyleNode(styleNode);
-    if (!css) return;
-    // Improve performance by avoiding calling stripCdata again and again
-    let isCdataWrapped = false;
-    if (css.includes('CDATA')) {
-        const strippedCss = stripCdata(css);
-        isCdataWrapped = css !== strippedCss;
-        css = strippedCss;
-    }
+    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)=>{
-        if (isCdataWrapped) {
-            styleNode.content = [
-                '<![CDATA[' + result.toString() + ']]>'
-            ];
-        } else {
-            styleNode.content = [
-                result.css
-            ];
-        }
+        const minifiedCss = isCdataWrapped ? result.toString() : result.css;
+        styleNode.content = [
+            helpers_js.wrapCssCdata(minifiedCss, isCdataWrapped)
+        ];
     });
 }
 function processStyleAttr(node, cssnanoOptions, cssnano, postcss) {
@@ -67,7 +58,10 @@ function processStyleAttr(node, cssnanoOptions, cssnano, postcss) {
     // a{color: red;}
     const wrapperStart = 'a{';
     const wrapperEnd = '}';
-    if (!node.attrs || !node.attrs.style) {
+    if (!node.attrs || !node.attrs.style || typeof node.attrs.style !== 'string') {
+        return;
+    }
+    if (node.attrs.style.trim() === '') {
         return;
     }
     const wrappedStyle = wrapperStart + (node.attrs.style || '') + wrapperEnd;
@@ -79,13 +73,5 @@ function processStyleAttr(node, cssnanoOptions, cssnano, postcss) {
         node.attrs.style = minifiedCss.substring(wrapperStart.length, minifiedCss.length - wrapperEnd.length);
     });
 }
-function stripCdata(css) {
-    const leftStrippedCss = css.replace('<![CDATA[', '');
-    if (leftStrippedCss === css) {
-        return css;
-    }
-    const strippedCss = leftStrippedCss.replace(']]>', '');
-    return leftStrippedCss === strippedCss ? css : strippedCss;
-}
 
 exports.default = mod;

package/dist/_modules/minifyCss.mjs

@@ -1,4 +1,4 @@
-import { optionalImport, isStyleNode, extractCssFromStyleNode } from '../helpers.mjs';
+import { optionalImport, isStyleNode, isCssStyleType, extractCssFromStyleNode, stripCssCdata, wrapCssCdata } from '../helpers.mjs';
 
 const postcssOptions = {
     // Prevent the following warning from being shown:
@@ -20,7 +20,7 @@ const postcssOptions = {
             if (node.attrs && 'integrity' in node.attrs) {
                 return node;
             }
-            if (isStyleNode(node)) {
+            if (isStyleNode(node) && isCssStyleType(node)) {
                 p = processStyleNode(node, cssnanoOptions, cssnano, postcss);
                 if (p) {
                     promises.push(p);
@@ -38,26 +38,17 @@ const postcssOptions = {
 };
 function processStyleNode(styleNode, cssnanoOptions, cssnano, postcss) {
     let css = extractCssFromStyleNode(styleNode);
-    if (!css) return;
-    // Improve performance by avoiding calling stripCdata again and again
-    let isCdataWrapped = false;
-    if (css.includes('CDATA')) {
-        const strippedCss = stripCdata(css);
-        isCdataWrapped = css !== strippedCss;
-        css = strippedCss;
-    }
+    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)=>{
-        if (isCdataWrapped) {
-            styleNode.content = [
-                '<![CDATA[' + result.toString() + ']]>'
-            ];
-        } else {
-            styleNode.content = [
-                result.css
-            ];
-        }
+        const minifiedCss = isCdataWrapped ? result.toString() : result.css;
+        styleNode.content = [
+            wrapCssCdata(minifiedCss, isCdataWrapped)
+        ];
     });
 }
 function processStyleAttr(node, cssnanoOptions, cssnano, postcss) {
@@ -65,7 +56,10 @@ function processStyleAttr(node, cssnanoOptions, cssnano, postcss) {
     // a{color: red;}
     const wrapperStart = 'a{';
     const wrapperEnd = '}';
-    if (!node.attrs || !node.attrs.style) {
+    if (!node.attrs || !node.attrs.style || typeof node.attrs.style !== 'string') {
+        return;
+    }
+    if (node.attrs.style.trim() === '') {
         return;
     }
     const wrappedStyle = wrapperStart + (node.attrs.style || '') + wrapperEnd;
@@ -77,13 +71,5 @@ function processStyleAttr(node, cssnanoOptions, cssnano, postcss) {
         node.attrs.style = minifiedCss.substring(wrapperStart.length, minifiedCss.length - wrapperEnd.length);
     });
 }
-function stripCdata(css) {
-    const leftStrippedCss = css.replace('<![CDATA[', '');
-    if (leftStrippedCss === css) {
-        return css;
-    }
-    const strippedCss = leftStrippedCss.replace(']]>', '');
-    return leftStrippedCss === strippedCss ? css : strippedCss;
-}
 
 export { mod as default };

package/dist/_modules/minifyHtmlTemplate.d.mts

@@ -0,0 +1,91 @@
+import PostHTML from 'posthtml';
+import { MinifyOptions } from 'terser';
+import { Options } from 'cssnano';
+import { Config } from 'svgo';
+import { UserDefinedOptions } from 'purgecss';
+
+type PostHTMLTreeLike = [PostHTML.Node] & PostHTML.NodeAPI & {
+    options?: {
+        quoteAllAttributes?: boolean | undefined;
+        quoteStyle?: 0 | 1 | 2 | undefined;
+        replaceQuote?: boolean | undefined;
+    } | undefined;
+    render(): string;
+    render(node: PostHTML.Node | PostHTMLTreeLike, renderOptions?: any): string;
+};
+type MaybeArray<T> = T | Array<T>;
+type PostHTMLNodeLike = PostHTML.Node | string;
+type HtmlnanoTemplateRule = {
+    tag: string;
+    attrs?: Record<string, string | boolean | void>;
+};
+type MinifyHtmlTemplateOptions = boolean | HtmlnanoTemplateRule[];
+interface HtmlnanoOptions {
+    skipConfigLoading?: boolean;
+    configPath?: string;
+    skipInternalWarnings?: boolean;
+    collapseAttributeWhitespace?: boolean;
+    collapseBooleanAttributes?: {
+        amphtml?: boolean;
+    };
+    collapseWhitespace?: 'conservative' | 'all' | 'aggressive';
+    custom?: MaybeArray<(tree: PostHTMLTreeLike, options?: any) => (PostHTML.Node | PostHTMLTreeLike)>;
+    deduplicateAttributeValues?: boolean;
+    minifyUrls?: URL | string | false;
+    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 | {
+        force?: boolean;
+    };
+    removeComments?: boolean | RegExp | ((comment: string) => boolean) | string;
+    removeEmptyAttributes?: boolean;
+    removeEmptyElements?: boolean | {
+        removeWithAttributes?: boolean;
+    };
+    removeRedundantAttributes?: boolean;
+    removeOptionalTags?: 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';
+}
+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 HtmlnanoModule<Options = any> = {
+    onAttrs?: (options: Partial<HtmlnanoOptions>, moduleOptions: OptionalOptions<Options>) => HtmlnanoModuleAttrsHandler;
+    onContent?: (options: Partial<HtmlnanoOptions>, moduleOptions: OptionalOptions<Options>) => HtmlnanoModuleContentHandler;
+    onNode?: (options: Partial<HtmlnanoOptions>, moduleOptions: OptionalOptions<Options>) => HtmlnanoModuleNodeHandler;
+    default?: (tree: PostHTMLTreeLike, options: Partial<HtmlnanoOptions>, moduleOptions: OptionalOptions<Options>) => PostHTMLTreeLike | Promise<PostHTMLTreeLike>;
+};
+
+declare const defaultRules: HtmlnanoTemplateRule[];
+declare const mod: HtmlnanoModule<MinifyHtmlTemplateOptions>;
+
+export { mod as default, defaultRules };

package/dist/_modules/minifyHtmlTemplate.d.ts

@@ -0,0 +1,91 @@
+import PostHTML from 'posthtml';
+import { MinifyOptions } from 'terser';
+import { Options } from 'cssnano';
+import { Config } from 'svgo';
+import { UserDefinedOptions } from 'purgecss';
+
+type PostHTMLTreeLike = [PostHTML.Node] & PostHTML.NodeAPI & {
+    options?: {
+        quoteAllAttributes?: boolean | undefined;
+        quoteStyle?: 0 | 1 | 2 | undefined;
+        replaceQuote?: boolean | undefined;
+    } | undefined;
+    render(): string;
+    render(node: PostHTML.Node | PostHTMLTreeLike, renderOptions?: any): string;
+};
+type MaybeArray<T> = T | Array<T>;
+type PostHTMLNodeLike = PostHTML.Node | string;
+type HtmlnanoTemplateRule = {
+    tag: string;
+    attrs?: Record<string, string | boolean | void>;
+};
+type MinifyHtmlTemplateOptions = boolean | HtmlnanoTemplateRule[];
+interface HtmlnanoOptions {
+    skipConfigLoading?: boolean;
+    configPath?: string;
+    skipInternalWarnings?: boolean;
+    collapseAttributeWhitespace?: boolean;
+    collapseBooleanAttributes?: {
+        amphtml?: boolean;
+    };
+    collapseWhitespace?: 'conservative' | 'all' | 'aggressive';
+    custom?: MaybeArray<(tree: PostHTMLTreeLike, options?: any) => (PostHTML.Node | PostHTMLTreeLike)>;
+    deduplicateAttributeValues?: boolean;
+    minifyUrls?: URL | string | false;
+    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 | {
+        force?: boolean;
+    };
+    removeComments?: boolean | RegExp | ((comment: string) => boolean) | string;
+    removeEmptyAttributes?: boolean;
+    removeEmptyElements?: boolean | {
+        removeWithAttributes?: boolean;
+    };
+    removeRedundantAttributes?: boolean;
+    removeOptionalTags?: 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';
+}
+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 HtmlnanoModule<Options = any> = {
+    onAttrs?: (options: Partial<HtmlnanoOptions>, moduleOptions: OptionalOptions<Options>) => HtmlnanoModuleAttrsHandler;
+    onContent?: (options: Partial<HtmlnanoOptions>, moduleOptions: OptionalOptions<Options>) => HtmlnanoModuleContentHandler;
+    onNode?: (options: Partial<HtmlnanoOptions>, moduleOptions: OptionalOptions<Options>) => HtmlnanoModuleNodeHandler;
+    default?: (tree: PostHTMLTreeLike, options: Partial<HtmlnanoOptions>, moduleOptions: OptionalOptions<Options>) => PostHTMLTreeLike | Promise<PostHTMLTreeLike>;
+};
+
+declare const defaultRules: HtmlnanoTemplateRule[];
+declare const mod: HtmlnanoModule<MinifyHtmlTemplateOptions>;
+
+export { mod as default, defaultRules };