htmlnano 2.1.2 → 2.1.4

package/dist/helpers.js

@@ -0,0 +1,72 @@
+Object.defineProperty(exports, '__esModule', { value: true });
+
+const ampBoilerplateAttributes = [
+    'amp-boilerplate',
+    'amp4ads-boilerplate',
+    'amp4email-boilerplate'
+];
+function isAmpBoilerplate(node) {
+    if (!node.attrs) {
+        return false;
+    }
+    for (const attr of ampBoilerplateAttributes){
+        if (attr in node.attrs) {
+            return true;
+        }
+    }
+    return false;
+}
+function isComment(content) {
+    if (typeof content === 'string') {
+        return content.trim().startsWith('<!--');
+    }
+    return false;
+}
+function isConditionalComment(content) {
+    const clean = (content || '').trim();
+    return clean.startsWith('<!--[if') || clean === '<!--<![endif]-->';
+}
+function isStyleNode(node) {
+    return node.tag === 'style' && !isAmpBoilerplate(node) && 'content' in node && node.content && node.content.length > 0;
+}
+function extractCssFromStyleNode(node) {
+    return Array.isArray(node.content) ? node.content.join(' ') : node.content;
+}
+function isEventHandler(attributeName) {
+    return attributeName && attributeName.slice(0, 2).toLowerCase() === 'on' && attributeName.length >= 5;
+}
+function extractTextContentFromNode(node) {
+    if (!node.content) {
+        return '';
+    }
+    if (!Array.isArray(node.content)) {
+        return '';
+    }
+    let content = '';
+    for (const child of node.content){
+        if (typeof child === 'string') {
+            content += child;
+        }
+    }
+    return content;
+}
+async function optionalImport(moduleName) {
+    try {
+        const module = await import(moduleName);
+        return module.default || module;
+    } catch (e) {
+        if (typeof e === 'object' && e && 'code' in e && (e.code === 'MODULE_NOT_FOUND' || e.code === 'ERR_MODULE_NOT_FOUND')) {
+            return null;
+        }
+        throw e;
+    }
+}
+
+exports.extractCssFromStyleNode = extractCssFromStyleNode;
+exports.extractTextContentFromNode = extractTextContentFromNode;
+exports.isAmpBoilerplate = isAmpBoilerplate;
+exports.isComment = isComment;
+exports.isConditionalComment = isConditionalComment;
+exports.isEventHandler = isEventHandler;
+exports.isStyleNode = isStyleNode;
+exports.optionalImport = optionalImport;

package/dist/helpers.mjs

@@ -0,0 +1,63 @@
+const ampBoilerplateAttributes = [
+    'amp-boilerplate',
+    'amp4ads-boilerplate',
+    'amp4email-boilerplate'
+];
+function isAmpBoilerplate(node) {
+    if (!node.attrs) {
+        return false;
+    }
+    for (const attr of ampBoilerplateAttributes){
+        if (attr in node.attrs) {
+            return true;
+        }
+    }
+    return false;
+}
+function isComment(content) {
+    if (typeof content === 'string') {
+        return content.trim().startsWith('<!--');
+    }
+    return false;
+}
+function isConditionalComment(content) {
+    const clean = (content || '').trim();
+    return clean.startsWith('<!--[if') || clean === '<!--<![endif]-->';
+}
+function isStyleNode(node) {
+    return node.tag === 'style' && !isAmpBoilerplate(node) && 'content' in node && node.content && node.content.length > 0;
+}
+function extractCssFromStyleNode(node) {
+    return Array.isArray(node.content) ? node.content.join(' ') : node.content;
+}
+function isEventHandler(attributeName) {
+    return attributeName && attributeName.slice(0, 2).toLowerCase() === 'on' && attributeName.length >= 5;
+}
+function extractTextContentFromNode(node) {
+    if (!node.content) {
+        return '';
+    }
+    if (!Array.isArray(node.content)) {
+        return '';
+    }
+    let content = '';
+    for (const child of node.content){
+        if (typeof child === 'string') {
+            content += child;
+        }
+    }
+    return content;
+}
+async function optionalImport(moduleName) {
+    try {
+        const module = await import(moduleName);
+        return module.default || module;
+    } catch (e) {
+        if (typeof e === 'object' && e && 'code' in e && (e.code === 'MODULE_NOT_FOUND' || e.code === 'ERR_MODULE_NOT_FOUND')) {
+            return null;
+        }
+        throw e;
+    }
+}
+
+export { extractCssFromStyleNode, extractTextContentFromNode, isAmpBoilerplate, isComment, isConditionalComment, isEventHandler, isStyleNode, optionalImport };

package/dist/index.d.ts

@@ -0,0 +1,79 @@
+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';
+}
+interface HtmlnanoPreset extends Omit<HtmlnanoOptions, 'skipConfigLoading'> {
+}
+type HtmlnanoPredefinedPreset = 'safe' | 'ampSafe' | 'max';
+type HtmlnanoPredefinedPresets = Record<HtmlnanoPredefinedPreset, HtmlnanoPreset>;
+type HtmlnanoOptionsConfigFile = Omit<HtmlnanoOptions, 'skipConfigLoading'> & {
+    preset?: HtmlnanoPredefinedPreset;
+};
+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 function loadConfig(options?: HtmlnanoOptions, preset?: HtmlnanoPreset, configPath?: string): [Partial<HtmlnanoOptions>, HtmlnanoPreset];
+declare function htmlnano(optionsRun?: HtmlnanoOptions, presetRun?: HtmlnanoPreset): PostHTML.Plugin<never>;
+declare namespace htmlnano {
+    var presets: HtmlnanoPredefinedPresets;
+    var getRequiredOptionalDependencies: typeof getRequiredOptionalDependencies;
+    var process: typeof process;
+    var htmlMinimizerWebpackPluginMinify: typeof htmlMinimizerWebpackPluginMinify;
+    var loadConfig: typeof loadConfig;
+}
+declare function getRequiredOptionalDependencies(optionsRun: HtmlnanoOptions, presetRun: HtmlnanoPreset): string[];
+declare function process(html: string, options?: HtmlnanoOptions, preset?: HtmlnanoPreset, postHtmlOptions?: PostHTML.Options): Promise<PostHTML.Result<unknown>>;
+declare function htmlMinimizerWebpackPluginMinify(input: {
+    [file: string]: string;
+}, minimizerOptions?: HtmlnanoOptions): Promise<{
+    code: string;
+}>;
+
+export { htmlnano as default, getRequiredOptionalDependencies, htmlMinimizerWebpackPluginMinify, htmlnano, loadConfig, process };
+export type { HtmlnanoModule, HtmlnanoModuleAttrsHandler, HtmlnanoModuleContentHandler, HtmlnanoModuleNodeHandler, HtmlnanoOptions, HtmlnanoOptionsConfigFile, HtmlnanoPredefinedPreset, HtmlnanoPredefinedPresets, HtmlnanoPreset, PostHTMLNodeLike, PostHTMLTreeLike };

package/dist/index.js

@@ -0,0 +1,223 @@
+Object.defineProperty(exports, '__esModule', { value: true });
+
+var posthtml = require('posthtml');
+var cosmiconfig = require('cosmiconfig');
+var safePreset = require('./presets/safe.js');
+var ampSafePreset = require('./presets/ampSafe.js');
+var maxPreset = require('./presets/max.js');
+
+function _interopDefault (e) { return e && e.__esModule ? e : { default: e }; }
+
+var posthtml__default = /*#__PURE__*/_interopDefault(posthtml);
+var safePreset__default = /*#__PURE__*/_interopDefault(safePreset);
+var ampSafePreset__default = /*#__PURE__*/_interopDefault(ampSafePreset);
+var maxPreset__default = /*#__PURE__*/_interopDefault(maxPreset);
+
+const presets = {
+    safe: safePreset__default.default,
+    ampSafe: ampSafePreset__default.default,
+    max: maxPreset__default.default
+};
+function loadConfig(options, preset, configPath) {
+    const { skipConfigLoading = false, ...rest } = options || {};
+    let restConfig = rest;
+    if (!skipConfigLoading) {
+        const explorer = cosmiconfig.cosmiconfigSync('htmlnano');
+        const rc = configPath ? explorer.load(configPath) : explorer.search();
+        if (rc) {
+            const { preset: presetName } = rc.config;
+            if (presetName) {
+                if (!preset && presetName in presets) {
+                    preset = presets[presetName];
+                }
+                delete rc.config.preset;
+            }
+            if (!options) {
+                restConfig = rc.config;
+            }
+        }
+    }
+    return [
+        restConfig || {},
+        preset || safePreset__default.default
+    ];
+}
+const optionalDependencies = {
+    minifyCss: [
+        'cssnano',
+        'postcss'
+    ],
+    minifyJs: [
+        'terser'
+    ],
+    minifyUrls: [
+        'relateurl',
+        'srcset',
+        'terser'
+    ],
+    minifySvg: [
+        'svgo'
+    ]
+};
+const interop = (imported)=>imported.then((mod)=>mod.default);
+const modules = {
+    collapseAttributeWhitespace: ()=>interop(import('./_modules/collapseAttributeWhitespace.js')),
+    collapseBooleanAttributes: ()=>interop(import('./_modules/collapseBooleanAttributes.js')),
+    collapseWhitespace: ()=>interop(import('./_modules/collapseWhitespace.js')),
+    custom: ()=>interop(import('./_modules/custom.js')),
+    deduplicateAttributeValues: ()=>interop(import('./_modules/deduplicateAttributeValues.js')),
+    // example: () => import('./_modules/example.mjs'),
+    mergeScripts: ()=>interop(import('./_modules/mergeScripts.js')),
+    mergeStyles: ()=>interop(import('./_modules/mergeStyles.js')),
+    minifyConditionalComments: ()=>interop(import('./_modules/minifyConditionalComments.js')),
+    minifyCss: ()=>interop(import('./_modules/minifyCss.js')),
+    minifyJs: ()=>interop(import('./_modules/minifyJs.js')),
+    minifyJson: ()=>interop(import('./_modules/minifyJson.js')),
+    minifySvg: ()=>interop(import('./_modules/minifySvg.js')),
+    minifyUrls: ()=>interop(import('./_modules/minifyUrls.js')),
+    normalizeAttributeValues: ()=>interop(import('./_modules/normalizeAttributeValues.js')),
+    removeAttributeQuotes: ()=>interop(import('./_modules/removeAttributeQuotes.js')),
+    removeComments: ()=>interop(import('./_modules/removeComments.js')),
+    removeEmptyAttributes: ()=>interop(import('./_modules/removeEmptyAttributes.js')),
+    removeOptionalTags: ()=>interop(import('./_modules/removeOptionalTags.js')),
+    removeRedundantAttributes: ()=>interop(import('./_modules/removeRedundantAttributes.js')),
+    removeUnusedCss: ()=>interop(import('./_modules/removeUnusedCss.js')),
+    sortAttributes: ()=>interop(import('./_modules/sortAttributes.js')),
+    sortAttributesWithLists: ()=>interop(import('./_modules/sortAttributesWithLists.js'))
+};
+function htmlnano(optionsRun = {}, presetRun) {
+    // eslint-disable-next-line prefer-const -- re-assign options
+    let [options, preset] = loadConfig(optionsRun, presetRun);
+    const minifier = async (_tree)=>{
+        const tree = _tree;
+        const nodeHandlers = [];
+        const attrsHandlers = [];
+        const contentsHandlers = [];
+        options = {
+            ...preset,
+            ...options
+        };
+        let promise = Promise.resolve(tree);
+        for (const [moduleName, moduleOptions] of Object.entries(options)){
+            if (!moduleOptions) {
+                continue;
+            }
+            if (!(moduleName in safePreset__default.default)) {
+                throw new Error('Module "' + moduleName + '" is not defined');
+            }
+            if (moduleName in optionalDependencies) {
+                const modules = optionalDependencies[moduleName];
+                await Promise.all(modules.map(async (dependency)=>{
+                    try {
+                        await import(dependency);
+                    } catch (e) {
+                        if (typeof e === 'object' && e !== null && 'code' in e && typeof e.code === 'string') {
+                            if (e.code === 'MODULE_NOT_FOUND' || e.code === 'ERR_MODULE_NOT_FOUND') {
+                                if (!options.skipInternalWarnings) {
+                                    console.warn(`You have to install "${dependency}" in order to use htmlnano's "${moduleName}" module`);
+                                    return;
+                                }
+                            }
+                            throw e;
+                        }
+                    }
+                }));
+            }
+            const mod = moduleName in modules ? await modules[moduleName]() : await import(`./_modules/${moduleName}.mjs`);
+            if (typeof mod.onAttrs === 'function') {
+                attrsHandlers.push(mod.onAttrs(options, moduleOptions));
+            }
+            if (typeof mod.onContent === 'function') {
+                contentsHandlers.push(mod.onContent(options, moduleOptions));
+            }
+            if (typeof mod.onNode === 'function') {
+                nodeHandlers.push(mod.onNode(options, moduleOptions));
+            }
+            if (typeof mod.default === 'function') {
+                promise = promise.then(async (tree)=>await mod.default(tree, options, moduleOptions));
+            }
+        }
+        if (attrsHandlers.length + contentsHandlers.length + nodeHandlers.length === 0) {
+            return promise;
+        }
+        return promise.then((tree)=>{
+            tree.walk((node)=>{
+                if (node) {
+                    if (node.attrs && typeof node.attrs === 'object') {
+                        // Convert all attrs' key to lower case
+                        let newAttrsObj = {};
+                        Object.entries(node.attrs).forEach(([attrName, attrValue])=>{
+                            newAttrsObj[attrName.toLowerCase()] = attrValue;
+                        });
+                        for (const handler of attrsHandlers){
+                            newAttrsObj = handler(newAttrsObj, node);
+                        }
+                        node.attrs = newAttrsObj;
+                    }
+                    if (node.content) {
+                        node.content = typeof node.content === 'string' ? [
+                            node.content
+                        ] : node.content;
+                        if (Array.isArray(node.content) && node.content.length > 0) {
+                            for (const handler of contentsHandlers){
+                                var _node_content;
+                                const result = handler((_node_content = node.content) != null ? _node_content : [], node);
+                                node.content = Array.isArray(result) ? result : [
+                                    result
+                                ];
+                            }
+                        }
+                    }
+                    for (const handler of nodeHandlers){
+                        if (handler) {
+                            node = handler(node);
+                        }
+                    }
+                }
+                return node;
+            });
+            return tree;
+        });
+    };
+    return minifier;
+}
+function getRequiredOptionalDependencies(optionsRun, presetRun) {
+    const [options] = loadConfig(optionsRun, presetRun);
+    return Array.from(Object.keys(options).reduce((acc, moduleName)=>{
+        if (moduleName in optionalDependencies) {
+            const dependencies = optionalDependencies[moduleName];
+            // eslint-disable-next-line @typescript-eslint/unbound-method -- thisArg provided by forEach
+            dependencies.forEach(acc.add, acc);
+        }
+        return acc;
+    }, new Set()));
+}
+function process(html, options, preset, postHtmlOptions) {
+    return posthtml__default.default([
+        htmlnano(options, preset)
+    ]).process(html, postHtmlOptions);
+}
+// https://github.com/webpack-contrib/html-minimizer-webpack-plugin/blob/faca00f2219514bc671c5942685721f0b5dbaa70/src/utils.js#L74
+function htmlMinimizerWebpackPluginMinify(input, minimizerOptions) {
+    const [[, code]] = Object.entries(input);
+    return htmlnano.process(code, minimizerOptions, presets.safe).then((result)=>{
+        return {
+            code: result.html
+        };
+    });
+}
+htmlnano.presets = presets;
+htmlnano.getRequiredOptionalDependencies = getRequiredOptionalDependencies;
+htmlnano.process = process;
+htmlnano.htmlMinimizerWebpackPluginMinify = htmlMinimizerWebpackPluginMinify;
+htmlnano.loadConfig = loadConfig;
+if (typeof module !== 'undefined') {
+    module.exports = htmlnano;
+}
+
+exports.default = htmlnano;
+exports.getRequiredOptionalDependencies = getRequiredOptionalDependencies;
+exports.htmlMinimizerWebpackPluginMinify = htmlMinimizerWebpackPluginMinify;
+exports.htmlnano = htmlnano;
+exports.loadConfig = loadConfig;
+exports.process = process;

package/dist/index.mjs

@@ -0,0 +1,209 @@
+import posthtml from 'posthtml';
+import { cosmiconfigSync } from 'cosmiconfig';
+import safePreset from './presets/safe.mjs';
+import ampSafePreset from './presets/ampSafe.mjs';
+import maxPreset from './presets/max.mjs';
+
+const presets = {
+    safe: safePreset,
+    ampSafe: ampSafePreset,
+    max: maxPreset
+};
+function loadConfig(options, preset, configPath) {
+    const { skipConfigLoading = false, ...rest } = options || {};
+    let restConfig = rest;
+    if (!skipConfigLoading) {
+        const explorer = cosmiconfigSync('htmlnano');
+        const rc = configPath ? explorer.load(configPath) : explorer.search();
+        if (rc) {
+            const { preset: presetName } = rc.config;
+            if (presetName) {
+                if (!preset && presetName in presets) {
+                    preset = presets[presetName];
+                }
+                delete rc.config.preset;
+            }
+            if (!options) {
+                restConfig = rc.config;
+            }
+        }
+    }
+    return [
+        restConfig || {},
+        preset || safePreset
+    ];
+}
+const optionalDependencies = {
+    minifyCss: [
+        'cssnano',
+        'postcss'
+    ],
+    minifyJs: [
+        'terser'
+    ],
+    minifyUrls: [
+        'relateurl',
+        'srcset',
+        'terser'
+    ],
+    minifySvg: [
+        'svgo'
+    ]
+};
+const interop = (imported)=>imported.then((mod)=>mod.default);
+const modules = {
+    collapseAttributeWhitespace: ()=>interop(import('./_modules/collapseAttributeWhitespace.mjs')),
+    collapseBooleanAttributes: ()=>interop(import('./_modules/collapseBooleanAttributes.mjs')),
+    collapseWhitespace: ()=>interop(import('./_modules/collapseWhitespace.mjs')),
+    custom: ()=>interop(import('./_modules/custom.mjs')),
+    deduplicateAttributeValues: ()=>interop(import('./_modules/deduplicateAttributeValues.mjs')),
+    // example: () => import('./_modules/example.mjs'),
+    mergeScripts: ()=>interop(import('./_modules/mergeScripts.mjs')),
+    mergeStyles: ()=>interop(import('./_modules/mergeStyles.mjs')),
+    minifyConditionalComments: ()=>interop(import('./_modules/minifyConditionalComments.mjs')),
+    minifyCss: ()=>interop(import('./_modules/minifyCss.mjs')),
+    minifyJs: ()=>interop(import('./_modules/minifyJs.mjs')),
+    minifyJson: ()=>interop(import('./_modules/minifyJson.mjs')),
+    minifySvg: ()=>interop(import('./_modules/minifySvg.mjs')),
+    minifyUrls: ()=>interop(import('./_modules/minifyUrls.mjs')),
+    normalizeAttributeValues: ()=>interop(import('./_modules/normalizeAttributeValues.mjs')),
+    removeAttributeQuotes: ()=>interop(import('./_modules/removeAttributeQuotes.mjs')),
+    removeComments: ()=>interop(import('./_modules/removeComments.mjs')),
+    removeEmptyAttributes: ()=>interop(import('./_modules/removeEmptyAttributes.mjs')),
+    removeOptionalTags: ()=>interop(import('./_modules/removeOptionalTags.mjs')),
+    removeRedundantAttributes: ()=>interop(import('./_modules/removeRedundantAttributes.mjs')),
+    removeUnusedCss: ()=>interop(import('./_modules/removeUnusedCss.mjs')),
+    sortAttributes: ()=>interop(import('./_modules/sortAttributes.mjs')),
+    sortAttributesWithLists: ()=>interop(import('./_modules/sortAttributesWithLists.mjs'))
+};
+function htmlnano(optionsRun = {}, presetRun) {
+    // eslint-disable-next-line prefer-const -- re-assign options
+    let [options, preset] = loadConfig(optionsRun, presetRun);
+    const minifier = async (_tree)=>{
+        const tree = _tree;
+        const nodeHandlers = [];
+        const attrsHandlers = [];
+        const contentsHandlers = [];
+        options = {
+            ...preset,
+            ...options
+        };
+        let promise = Promise.resolve(tree);
+        for (const [moduleName, moduleOptions] of Object.entries(options)){
+            if (!moduleOptions) {
+                continue;
+            }
+            if (!(moduleName in safePreset)) {
+                throw new Error('Module "' + moduleName + '" is not defined');
+            }
+            if (moduleName in optionalDependencies) {
+                const modules = optionalDependencies[moduleName];
+                await Promise.all(modules.map(async (dependency)=>{
+                    try {
+                        await import(dependency);
+                    } catch (e) {
+                        if (typeof e === 'object' && e !== null && 'code' in e && typeof e.code === 'string') {
+                            if (e.code === 'MODULE_NOT_FOUND' || e.code === 'ERR_MODULE_NOT_FOUND') {
+                                if (!options.skipInternalWarnings) {
+                                    console.warn(`You have to install "${dependency}" in order to use htmlnano's "${moduleName}" module`);
+                                    return;
+                                }
+                            }
+                            throw e;
+                        }
+                    }
+                }));
+            }
+            const mod = moduleName in modules ? await modules[moduleName]() : await import(`./_modules/${moduleName}.mjs`);
+            if (typeof mod.onAttrs === 'function') {
+                attrsHandlers.push(mod.onAttrs(options, moduleOptions));
+            }
+            if (typeof mod.onContent === 'function') {
+                contentsHandlers.push(mod.onContent(options, moduleOptions));
+            }
+            if (typeof mod.onNode === 'function') {
+                nodeHandlers.push(mod.onNode(options, moduleOptions));
+            }
+            if (typeof mod.default === 'function') {
+                promise = promise.then(async (tree)=>await mod.default(tree, options, moduleOptions));
+            }
+        }
+        if (attrsHandlers.length + contentsHandlers.length + nodeHandlers.length === 0) {
+            return promise;
+        }
+        return promise.then((tree)=>{
+            tree.walk((node)=>{
+                if (node) {
+                    if (node.attrs && typeof node.attrs === 'object') {
+                        // Convert all attrs' key to lower case
+                        let newAttrsObj = {};
+                        Object.entries(node.attrs).forEach(([attrName, attrValue])=>{
+                            newAttrsObj[attrName.toLowerCase()] = attrValue;
+                        });
+                        for (const handler of attrsHandlers){
+                            newAttrsObj = handler(newAttrsObj, node);
+                        }
+                        node.attrs = newAttrsObj;
+                    }
+                    if (node.content) {
+                        node.content = typeof node.content === 'string' ? [
+                            node.content
+                        ] : node.content;
+                        if (Array.isArray(node.content) && node.content.length > 0) {
+                            for (const handler of contentsHandlers){
+                                var _node_content;
+                                const result = handler((_node_content = node.content) != null ? _node_content : [], node);
+                                node.content = Array.isArray(result) ? result : [
+                                    result
+                                ];
+                            }
+                        }
+                    }
+                    for (const handler of nodeHandlers){
+                        if (handler) {
+                            node = handler(node);
+                        }
+                    }
+                }
+                return node;
+            });
+            return tree;
+        });
+    };
+    return minifier;
+}
+function getRequiredOptionalDependencies(optionsRun, presetRun) {
+    const [options] = loadConfig(optionsRun, presetRun);
+    return Array.from(Object.keys(options).reduce((acc, moduleName)=>{
+        if (moduleName in optionalDependencies) {
+            const dependencies = optionalDependencies[moduleName];
+            // eslint-disable-next-line @typescript-eslint/unbound-method -- thisArg provided by forEach
+            dependencies.forEach(acc.add, acc);
+        }
+        return acc;
+    }, new Set()));
+}
+function process(html, options, preset, postHtmlOptions) {
+    return posthtml([
+        htmlnano(options, preset)
+    ]).process(html, postHtmlOptions);
+}
+// https://github.com/webpack-contrib/html-minimizer-webpack-plugin/blob/faca00f2219514bc671c5942685721f0b5dbaa70/src/utils.js#L74
+function htmlMinimizerWebpackPluginMinify(input, minimizerOptions) {
+    const [[, code]] = Object.entries(input);
+    return htmlnano.process(code, minimizerOptions, presets.safe).then((result)=>{
+        return {
+            code: result.html
+        };
+    });
+}
+htmlnano.presets = presets;
+htmlnano.getRequiredOptionalDependencies = getRequiredOptionalDependencies;
+htmlnano.process = process;
+htmlnano.htmlMinimizerWebpackPluginMinify = htmlMinimizerWebpackPluginMinify;
+htmlnano.loadConfig = loadConfig;
+if (typeof module !== 'undefined') {
+    module.exports = htmlnano;
+}
+
+export { htmlnano as default, getRequiredOptionalDependencies, htmlMinimizerWebpackPluginMinify, htmlnano, loadConfig, process };