htmlnano 3.0.0 → 3.1.0

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 };

package/dist/_modules/minifyHtmlTemplate.js

@@ -0,0 +1,231 @@
+Object.defineProperty(exports, '__esModule', { value: true });
+
+var helpers_js = require('../helpers.js');
+
+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.js');
+        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 helpers_js.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;
+}
+
+exports.default = mod;
+exports.defaultRules = defaultRules;