htmlnano 2.1.1 → 2.1.3

package/dist/_modules/minifyCss.js

@@ -0,0 +1,84 @@
+Object.defineProperty(exports, '__esModule', { value: true });
+
+var helpers_js = require('../helpers.js');
+
+const postcssOptions = {
+    // Prevent the following warning from being shown:
+    // > Without `from` option PostCSS could generate wrong source map and will not find Browserslist config.
+    // > Set it to CSS file path or to `undefined` to prevent this warning.
+    from: undefined
+};
+/** Minify CSS with cssnano */ const mod = {
+    async default (tree, _, cssnanoOptions) {
+        const cssnano = await helpers_js.optionalImport('cssnano');
+        const postcss = await helpers_js.optionalImport('postcss');
+        if (!cssnano || !postcss) {
+            return tree;
+        }
+        const promises = [];
+        tree.walk((node)=>{
+            // Skip SRI, reasons are documented in "minifyJs" module
+            if (node.attrs && 'integrity' in node.attrs) {
+                return node;
+            }
+            if (helpers_js.isStyleNode(node)) {
+                promises.push(processStyleNode(node, cssnanoOptions, cssnano, postcss));
+            } else if (node.attrs && node.attrs.style) {
+                promises.push(processStyleAttr(node, cssnanoOptions, cssnano, postcss));
+            }
+            return node;
+        });
+        return Promise.all(promises).then(()=>tree);
+    }
+};
+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;
+    }
+    return postcss([
+        cssnano(cssnanoOptions)
+    ]).process(css, postcssOptions).then((result)=>{
+        if (isCdataWrapped) {
+            styleNode.content = [
+                '<![CDATA[' + result.toString() + ']]>'
+            ];
+        } else {
+            styleNode.content = [
+                result.css
+            ];
+        }
+    });
+}
+function processStyleAttr(node, cssnanoOptions, cssnano, postcss) {
+    // CSS "color: red;" is invalid. Therefore it should be wrapped inside some selector:
+    // a{color: red;}
+    const wrapperStart = 'a{';
+    const wrapperEnd = '}';
+    if (!node.attrs || !node.attrs.style) {
+        return;
+    }
+    const wrappedStyle = wrapperStart + (node.attrs.style || '') + wrapperEnd;
+    return postcss([
+        cssnano(cssnanoOptions)
+    ]).process(wrappedStyle, postcssOptions).then((result)=>{
+        const minifiedCss = result.css;
+        // Remove wrapperStart at the start and wrapperEnd at the end of minifiedCss
+        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

@@ -0,0 +1,82 @@
+import { optionalImport, isStyleNode, extractCssFromStyleNode } from '../helpers.mjs';
+
+const postcssOptions = {
+    // Prevent the following warning from being shown:
+    // > Without `from` option PostCSS could generate wrong source map and will not find Browserslist config.
+    // > Set it to CSS file path or to `undefined` to prevent this warning.
+    from: undefined
+};
+/** Minify CSS with cssnano */ const mod = {
+    async default (tree, _, cssnanoOptions) {
+        const cssnano = await optionalImport('cssnano');
+        const postcss = await optionalImport('postcss');
+        if (!cssnano || !postcss) {
+            return tree;
+        }
+        const promises = [];
+        tree.walk((node)=>{
+            // Skip SRI, reasons are documented in "minifyJs" module
+            if (node.attrs && 'integrity' in node.attrs) {
+                return node;
+            }
+            if (isStyleNode(node)) {
+                promises.push(processStyleNode(node, cssnanoOptions, cssnano, postcss));
+            } else if (node.attrs && node.attrs.style) {
+                promises.push(processStyleAttr(node, cssnanoOptions, cssnano, postcss));
+            }
+            return node;
+        });
+        return Promise.all(promises).then(()=>tree);
+    }
+};
+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;
+    }
+    return postcss([
+        cssnano(cssnanoOptions)
+    ]).process(css, postcssOptions).then((result)=>{
+        if (isCdataWrapped) {
+            styleNode.content = [
+                '<![CDATA[' + result.toString() + ']]>'
+            ];
+        } else {
+            styleNode.content = [
+                result.css
+            ];
+        }
+    });
+}
+function processStyleAttr(node, cssnanoOptions, cssnano, postcss) {
+    // CSS "color: red;" is invalid. Therefore it should be wrapped inside some selector:
+    // a{color: red;}
+    const wrapperStart = 'a{';
+    const wrapperEnd = '}';
+    if (!node.attrs || !node.attrs.style) {
+        return;
+    }
+    const wrappedStyle = wrapperStart + (node.attrs.style || '') + wrapperEnd;
+    return postcss([
+        cssnano(cssnanoOptions)
+    ]).process(wrappedStyle, postcssOptions).then((result)=>{
+        const minifiedCss = result.css;
+        // Remove wrapperStart at the start and wrapperEnd at the end of minifiedCss
+        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/minifyJs.d.mts

@@ -0,0 +1,56 @@
+import PostHTML from 'posthtml';
+import { MinifyOptions } from 'terser';
+import { Options } from 'cssnano';
+import { Config } from 'svgo';
+
+type PostHTMLTreeLike = [PostHTML.Node] & PostHTML.NodeAPI & {
+    options?: {
+        quoteAllAttributes?: boolean | undefined;
+    } | undefined;
+    render(): string;
+    render(node: PostHTML.Node | PostHTMLTreeLike, renderOptions?: any): string;
+};
+type MaybeArray<T> = T | Array<T>;
+type PostHTMLNodeLike = PostHTML.Node | string;
+interface HtmlnanoOptions {
+    skipConfigLoading?: boolean;
+    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;
+    minifyConditionalComments?: boolean;
+    minifyJs?: MinifyOptions | boolean;
+    minifyJson?: boolean;
+    minifySvg?: Config | boolean;
+    normalizeAttributeValues?: boolean;
+    removeAttributeQuotes?: boolean;
+    removeComments?: boolean | 'safe' | 'all' | RegExp | ((comment: string) => boolean);
+    removeEmptyAttributes?: boolean;
+    removeRedundantAttributes?: boolean;
+    removeOptionalTags?: boolean;
+    removeUnusedCss?: boolean;
+    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 mod: HtmlnanoModule<MinifyOptions>;
+
+export { mod as default };

package/dist/_modules/minifyJs.d.ts

@@ -0,0 +1,56 @@
+import PostHTML from 'posthtml';
+import { MinifyOptions } from 'terser';
+import { Options } from 'cssnano';
+import { Config } from 'svgo';
+
+type PostHTMLTreeLike = [PostHTML.Node] & PostHTML.NodeAPI & {
+    options?: {
+        quoteAllAttributes?: boolean | undefined;
+    } | undefined;
+    render(): string;
+    render(node: PostHTML.Node | PostHTMLTreeLike, renderOptions?: any): string;
+};
+type MaybeArray<T> = T | Array<T>;
+type PostHTMLNodeLike = PostHTML.Node | string;
+interface HtmlnanoOptions {
+    skipConfigLoading?: boolean;
+    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;
+    minifyConditionalComments?: boolean;
+    minifyJs?: MinifyOptions | boolean;
+    minifyJson?: boolean;
+    minifySvg?: Config | boolean;
+    normalizeAttributeValues?: boolean;
+    removeAttributeQuotes?: boolean;
+    removeComments?: boolean | 'safe' | 'all' | RegExp | ((comment: string) => boolean);
+    removeEmptyAttributes?: boolean;
+    removeRedundantAttributes?: boolean;
+    removeOptionalTags?: boolean;
+    removeUnusedCss?: boolean;
+    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 mod: HtmlnanoModule<MinifyOptions>;
+
+export { mod as default };

package/dist/_modules/minifyJs.js

@@ -0,0 +1,108 @@
+Object.defineProperty(exports, '__esModule', { value: true });
+
+var helpers_js = require('../helpers.js');
+var removeRedundantAttributes_js = require('./removeRedundantAttributes.js');
+
+/** Minify JS with Terser */ const mod = {
+    async default (tree, _, terserOptions) {
+        const terser = await helpers_js.optionalImport('terser');
+        if (!terser) return tree;
+        const promises = [];
+        tree.walk((node)=>{
+            const nodeAttrs = node.attrs || {};
+            /**
+         * Skip SRI
+         *
+         * If the input <script /> has an SRI attribute, it means that the original <script /> could be trusted,
+         * and should not be altered anymore.
+         *
+         * htmlnano is exactly an MITM that SRI is designed to protect from. If htmlnano or its dependencies get
+         * compromised and introduces malicious code, then it is up to the original SRI to protect the end user.
+         *
+         * So htmlnano will simply skip <script /> that has SRI.
+         * If developers do trust htmlnano, they should generate SRI after htmlnano modify the <script />.
+         */ if ('integrity' in nodeAttrs) {
+                return node;
+            }
+            if (node.tag && node.tag === 'script') {
+                const mimeType = nodeAttrs.type || 'text/javascript';
+                if (removeRedundantAttributes_js.redundantScriptTypes.has(mimeType) || mimeType === 'module') {
+                    promises.push(processScriptNode(node, terserOptions, terser));
+                }
+            }
+            if (node.attrs) {
+                promises.push.apply(processNodeWithOnAttrs(node, terserOptions, terser));
+            }
+            return node;
+        });
+        return Promise.all(promises).then(()=>tree);
+    }
+};
+function stripCdata(js) {
+    const leftStrippedJs = js.replace(/\/\/\s*<!\[CDATA\[/, '').replace(/\/\*\s*<!\[CDATA\[\s*\*\//, '');
+    if (leftStrippedJs === js) {
+        return js;
+    }
+    const strippedJs = leftStrippedJs.replace(/\/\/\s*\]\]>/, '').replace(/\/\*\s*\]\]>\s*\*\//, '');
+    return leftStrippedJs === strippedJs ? js : strippedJs;
+}
+function processScriptNode(scriptNode, terserOptions, terser) {
+    let js = helpers_js.extractTextContentFromNode(scriptNode).trim();
+    if (!js.length) {
+        return;
+    }
+    // Improve performance by avoiding calling stripCdata again and again
+    let isCdataWrapped = false;
+    if (js.includes('CDATA')) {
+        const strippedJs = stripCdata(js);
+        isCdataWrapped = js !== strippedJs;
+        js = strippedJs;
+    }
+    return terser.minify(js, terserOptions).then((result)=>{
+        if ('error' in result) {
+            throw new Error(result.error);
+        }
+        if (result.code === undefined) {
+            return;
+        }
+        let content = result.code;
+        if (isCdataWrapped) {
+            content = '/*<![CDATA[*/' + content + '/*]]>*/';
+        }
+        scriptNode.content = [
+            content
+        ];
+    });
+}
+function processNodeWithOnAttrs(node, terserOptions, terser) {
+    const jsWrapperStart = 'a=function(){';
+    const jsWrapperEnd = '};a();';
+    const promises = [];
+    if (!node.attrs) {
+        return promises;
+    }
+    for(const attrName in node.attrs){
+        if (!helpers_js.isEventHandler(attrName)) {
+            continue;
+        }
+        const attrValue = node.attrs[attrName];
+        if (typeof attrValue !== 'string') {
+            continue;
+        }
+        // For example onclick="return false" is valid,
+        // but "return false;" is invalid (error: 'return' outside of function)
+        // 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 })=>{
+            if (code) {
+                const minifiedJs = code.substring(jsWrapperStart.length, code.length - jsWrapperEnd.length);
+                node.attrs[attrName] = minifiedJs;
+            }
+        });
+        promises.push(promise);
+    }
+    return promises;
+}
+
+exports.default = mod;

package/dist/_modules/minifyJs.mjs

@@ -0,0 +1,106 @@
+import { optionalImport, extractTextContentFromNode, isEventHandler } from '../helpers.mjs';
+import { redundantScriptTypes } from './removeRedundantAttributes.mjs';
+
+/** Minify JS with Terser */ const mod = {
+    async default (tree, _, terserOptions) {
+        const terser = await optionalImport('terser');
+        if (!terser) return tree;
+        const promises = [];
+        tree.walk((node)=>{
+            const nodeAttrs = node.attrs || {};
+            /**
+         * Skip SRI
+         *
+         * If the input <script /> has an SRI attribute, it means that the original <script /> could be trusted,
+         * and should not be altered anymore.
+         *
+         * htmlnano is exactly an MITM that SRI is designed to protect from. If htmlnano or its dependencies get
+         * compromised and introduces malicious code, then it is up to the original SRI to protect the end user.
+         *
+         * So htmlnano will simply skip <script /> that has SRI.
+         * If developers do trust htmlnano, they should generate SRI after htmlnano modify the <script />.
+         */ if ('integrity' in nodeAttrs) {
+                return node;
+            }
+            if (node.tag && node.tag === 'script') {
+                const mimeType = nodeAttrs.type || 'text/javascript';
+                if (redundantScriptTypes.has(mimeType) || mimeType === 'module') {
+                    promises.push(processScriptNode(node, terserOptions, terser));
+                }
+            }
+            if (node.attrs) {
+                promises.push.apply(processNodeWithOnAttrs(node, terserOptions, terser));
+            }
+            return node;
+        });
+        return Promise.all(promises).then(()=>tree);
+    }
+};
+function stripCdata(js) {
+    const leftStrippedJs = js.replace(/\/\/\s*<!\[CDATA\[/, '').replace(/\/\*\s*<!\[CDATA\[\s*\*\//, '');
+    if (leftStrippedJs === js) {
+        return js;
+    }
+    const strippedJs = leftStrippedJs.replace(/\/\/\s*\]\]>/, '').replace(/\/\*\s*\]\]>\s*\*\//, '');
+    return leftStrippedJs === strippedJs ? js : strippedJs;
+}
+function processScriptNode(scriptNode, terserOptions, terser) {
+    let js = extractTextContentFromNode(scriptNode).trim();
+    if (!js.length) {
+        return;
+    }
+    // Improve performance by avoiding calling stripCdata again and again
+    let isCdataWrapped = false;
+    if (js.includes('CDATA')) {
+        const strippedJs = stripCdata(js);
+        isCdataWrapped = js !== strippedJs;
+        js = strippedJs;
+    }
+    return terser.minify(js, terserOptions).then((result)=>{
+        if ('error' in result) {
+            throw new Error(result.error);
+        }
+        if (result.code === undefined) {
+            return;
+        }
+        let content = result.code;
+        if (isCdataWrapped) {
+            content = '/*<![CDATA[*/' + content + '/*]]>*/';
+        }
+        scriptNode.content = [
+            content
+        ];
+    });
+}
+function processNodeWithOnAttrs(node, terserOptions, terser) {
+    const jsWrapperStart = 'a=function(){';
+    const jsWrapperEnd = '};a();';
+    const promises = [];
+    if (!node.attrs) {
+        return promises;
+    }
+    for(const attrName in node.attrs){
+        if (!isEventHandler(attrName)) {
+            continue;
+        }
+        const attrValue = node.attrs[attrName];
+        if (typeof attrValue !== 'string') {
+            continue;
+        }
+        // For example onclick="return false" is valid,
+        // but "return false;" is invalid (error: 'return' outside of function)
+        // 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 })=>{
+            if (code) {
+                const minifiedJs = code.substring(jsWrapperStart.length, code.length - jsWrapperEnd.length);
+                node.attrs[attrName] = minifiedJs;
+            }
+        });
+        promises.push(promise);
+    }
+    return promises;
+}
+
+export { mod as default };

package/dist/_modules/minifyJson.d.mts

@@ -0,0 +1,56 @@
+import PostHTML from 'posthtml';
+import { MinifyOptions } from 'terser';
+import { Options } from 'cssnano';
+import { Config } from 'svgo';
+
+type PostHTMLTreeLike = [PostHTML.Node] & PostHTML.NodeAPI & {
+    options?: {
+        quoteAllAttributes?: boolean | undefined;
+    } | undefined;
+    render(): string;
+    render(node: PostHTML.Node | PostHTMLTreeLike, renderOptions?: any): string;
+};
+type MaybeArray<T> = T | Array<T>;
+type PostHTMLNodeLike = PostHTML.Node | string;
+interface HtmlnanoOptions {
+    skipConfigLoading?: boolean;
+    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;
+    minifyConditionalComments?: boolean;
+    minifyJs?: MinifyOptions | boolean;
+    minifyJson?: boolean;
+    minifySvg?: Config | boolean;
+    normalizeAttributeValues?: boolean;
+    removeAttributeQuotes?: boolean;
+    removeComments?: boolean | 'safe' | 'all' | RegExp | ((comment: string) => boolean);
+    removeEmptyAttributes?: boolean;
+    removeRedundantAttributes?: boolean;
+    removeOptionalTags?: boolean;
+    removeUnusedCss?: boolean;
+    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 mod: HtmlnanoModule;
+
+export { mod as default };

package/dist/_modules/minifyJson.d.ts

@@ -0,0 +1,56 @@
+import PostHTML from 'posthtml';
+import { MinifyOptions } from 'terser';
+import { Options } from 'cssnano';
+import { Config } from 'svgo';
+
+type PostHTMLTreeLike = [PostHTML.Node] & PostHTML.NodeAPI & {
+    options?: {
+        quoteAllAttributes?: boolean | undefined;
+    } | undefined;
+    render(): string;
+    render(node: PostHTML.Node | PostHTMLTreeLike, renderOptions?: any): string;
+};
+type MaybeArray<T> = T | Array<T>;
+type PostHTMLNodeLike = PostHTML.Node | string;
+interface HtmlnanoOptions {
+    skipConfigLoading?: boolean;
+    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;
+    minifyConditionalComments?: boolean;
+    minifyJs?: MinifyOptions | boolean;
+    minifyJson?: boolean;
+    minifySvg?: Config | boolean;
+    normalizeAttributeValues?: boolean;
+    removeAttributeQuotes?: boolean;
+    removeComments?: boolean | 'safe' | 'all' | RegExp | ((comment: string) => boolean);
+    removeEmptyAttributes?: boolean;
+    removeRedundantAttributes?: boolean;
+    removeOptionalTags?: boolean;
+    removeUnusedCss?: boolean;
+    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 mod: HtmlnanoModule;
+
+export { mod as default };

package/dist/_modules/minifyJson.js

@@ -0,0 +1,35 @@
+Object.defineProperty(exports, '__esModule', { value: true });
+
+const rNodeAttrsTypeJson = /(\/|\+)json/;
+const mod = {
+    onContent () {
+        return (content, node)=>{
+            // Skip SRI, reasons are documented in "minifyJs" module
+            if (node.attrs && 'integrity' in node.attrs) {
+                return content;
+            }
+            if (node.attrs && node.attrs.type && rNodeAttrsTypeJson.test(node.attrs.type)) {
+                try {
+                    // cast minified JSON to an array
+                    let jsonContent = '';
+                    for(let i = 0, len = content.length; i < len; i++){
+                        const item = content[i];
+                        if (typeof item === 'string') {
+                            jsonContent += item;
+                        } else {
+                            return content; // If any item is not a string, return original contents
+                        }
+                    }
+                    return [
+                        JSON.stringify(JSON.parse(jsonContent))
+                    ];
+                } catch (e) {
+                // Invalid JSON
+                }
+            }
+            return content;
+        };
+    }
+};
+
+exports.default = mod;

package/dist/_modules/minifyJson.mjs

@@ -0,0 +1,33 @@
+const rNodeAttrsTypeJson = /(\/|\+)json/;
+const mod = {
+    onContent () {
+        return (content, node)=>{
+            // Skip SRI, reasons are documented in "minifyJs" module
+            if (node.attrs && 'integrity' in node.attrs) {
+                return content;
+            }
+            if (node.attrs && node.attrs.type && rNodeAttrsTypeJson.test(node.attrs.type)) {
+                try {
+                    // cast minified JSON to an array
+                    let jsonContent = '';
+                    for(let i = 0, len = content.length; i < len; i++){
+                        const item = content[i];
+                        if (typeof item === 'string') {
+                            jsonContent += item;
+                        } else {
+                            return content; // If any item is not a string, return original contents
+                        }
+                    }
+                    return [
+                        JSON.stringify(JSON.parse(jsonContent))
+                    ];
+                } catch (e) {
+                // Invalid JSON
+                }
+            }
+            return content;
+        };
+    }
+};
+
+export { mod as default };