htmlnano 3.0.0 → 3.1.0

package/dist/_modules/minifyHtmlTemplate.mjs

@@ -0,0 +1,228 @@
+import { normalizeMimeType } from '../helpers.mjs';
+
+const defaultRules = [
+    {
+        tag: 'script',
+        attrs: {
+            type: 'text/html'
+        }
+    },
+    {
+        tag: 'script',
+        attrs: {
+            type: 'text/template'
+        }
+    },
+    {
+        tag: 'script',
+        attrs: {
+            type: 'text/x-template'
+        }
+    },
+    {
+        tag: 'script',
+        attrs: {
+            type: 'text/x-handlebars-template'
+        }
+    },
+    {
+        tag: 'script',
+        attrs: {
+            type: 'text/x-handlebars'
+        }
+    },
+    {
+        tag: 'script',
+        attrs: {
+            type: 'text/x-mustache-template'
+        }
+    },
+    {
+        tag: 'script',
+        attrs: {
+            type: 'text/x-underscore-template'
+        }
+    },
+    {
+        tag: 'script',
+        attrs: {
+            type: 'text/x-jsrender'
+        }
+    },
+    {
+        tag: 'script',
+        attrs: {
+            type: 'text/x-jquery-tmpl'
+        }
+    },
+    {
+        tag: 'script',
+        attrs: {
+            type: 'text/x-kendo-template'
+        }
+    },
+    {
+        tag: 'script',
+        attrs: {
+            type: 'text/ng-template'
+        }
+    },
+    {
+        tag: 'template'
+    }
+];
+const mod = {
+    async default (tree, options, moduleOptions) {
+        const rules = resolveTemplateRules(moduleOptions);
+        if (!rules.length) {
+            return tree;
+        }
+        const { default: htmlnano } = await import('../index.mjs');
+        const innerOptions = {
+            ...options,
+            minifyHtmlTemplate: false,
+            skipConfigLoading: true
+        };
+        const promises = [];
+        tree.walk((node)=>{
+            if (!node.tag) {
+                return node;
+            }
+            if (!matchesTemplateRule(node, rules)) {
+                return node;
+            }
+            if (node.attrs && 'integrity' in node.attrs) {
+                return node;
+            }
+            if (node.tag === 'script' && node.attrs && 'src' in node.attrs) {
+                return node;
+            }
+            const rawContent = collectNodeContent(tree, node);
+            if (rawContent.trim().length === 0) {
+                return node;
+            }
+            const promise = htmlnano.process(rawContent, innerOptions, {}, {}).then((result)=>{
+                node.content = [
+                    result.html
+                ];
+            });
+            promises.push(promise);
+            return node;
+        });
+        return Promise.all(promises).then(()=>tree);
+    }
+};
+function resolveTemplateRules(moduleOptions) {
+    if (!moduleOptions || moduleOptions === true) {
+        return normalizeRules(defaultRules);
+    }
+    if (Array.isArray(moduleOptions)) {
+        return normalizeRules(moduleOptions);
+    }
+    return normalizeRules(defaultRules);
+}
+function normalizeRules(rules) {
+    const normalized = [];
+    for (const rule of rules){
+        const resolved = normalizeRule(rule);
+        if (resolved) {
+            normalized.push(resolved);
+        }
+    }
+    return normalized;
+}
+function normalizeRule(rule) {
+    if (rule && typeof rule === 'object') {
+        if (typeof rule.tag !== 'string' || !rule.tag.trim()) {
+            return null;
+        }
+        const attrs = {};
+        if (rule.attrs && typeof rule.attrs === 'object') {
+            for (const [name, value] of Object.entries(rule.attrs)){
+                if (typeof name !== 'string' || !name.trim()) {
+                    continue;
+                }
+                attrs[name.toLowerCase()] = value != null ? value : true;
+            }
+        }
+        return {
+            tag: rule.tag.toLowerCase(),
+            attrs: Object.keys(attrs).length ? attrs : undefined
+        };
+    }
+    return null;
+}
+function matchesTemplateRule(node, rules) {
+    var _node_tag;
+    const tag = (_node_tag = node.tag) == null ? void 0 : _node_tag.toLowerCase();
+    if (!tag) {
+        return false;
+    }
+    const attrs = normalizeNodeAttrs(node);
+    for (const rule of rules){
+        if (tag !== rule.tag) {
+            continue;
+        }
+        if (!rule.attrs) {
+            return true;
+        }
+        let match = true;
+        for (const [attrName, ruleValue] of Object.entries(rule.attrs)){
+            if (!(attrName in attrs)) {
+                match = false;
+                break;
+            }
+            if (ruleValue === true) {
+                continue;
+            }
+            const nodeValue = normalizeAttrValue(attrName, attrs[attrName]);
+            const normalizedRuleValue = normalizeAttrValue(attrName, ruleValue);
+            if (nodeValue !== normalizedRuleValue) {
+                match = false;
+                break;
+            }
+        }
+        if (match) {
+            return true;
+        }
+    }
+    return false;
+}
+function normalizeNodeAttrs(node) {
+    if (!node.attrs) {
+        return {};
+    }
+    const normalized = {};
+    for (const [key, value] of Object.entries(node.attrs)){
+        normalized[key.toLowerCase()] = value;
+    }
+    return normalized;
+}
+function normalizeAttrValue(attrName, value) {
+    if (typeof value !== 'string') {
+        return value;
+    }
+    if (attrName === 'type') {
+        return normalizeMimeType(value);
+    }
+    return value;
+}
+function collectNodeContent(tree, node) {
+    if (!node.content) {
+        return '';
+    }
+    const content = typeof node.content === 'string' ? [
+        node.content
+    ] : node.content;
+    let html = '';
+    for (const child of content){
+        if (typeof child === 'string') {
+            html += child;
+        } else {
+            html += tree.render(child);
+        }
+    }
+    return html;
+}
+
+export { mod as default, defaultRules };

package/dist/_modules/minifyJs.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/minifyJs.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/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,7 +187,7 @@ 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;

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,7 +185,7 @@ 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;