htmlnano 2.1.2 → 2.1.3

package/dist/_modules/custom.d.ts

@@ -0,0 +1,57 @@
+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>;
+};
+
+type CustomModule = (tree: PostHTMLTreeLike, options: Partial<HtmlnanoOptions>) => PostHTMLTreeLike;
+declare const mod: HtmlnanoModule<CustomModule[]>;
+
+export { mod as default };

package/dist/_modules/custom.js

@@ -0,0 +1,22 @@
+Object.defineProperty(exports, '__esModule', { value: true });
+
+/** Meta-module that runs custom modules */ const mod = {
+    default: function custom(tree, options, customModules) {
+        if (!customModules) {
+            return tree;
+        }
+        if (!Array.isArray(customModules)) {
+            customModules = [
+                customModules
+            ];
+        }
+        customModules.forEach((customModule)=>{
+            if (customModule) {
+                tree = customModule(tree, options);
+            }
+        });
+        return tree;
+    }
+};
+
+exports.default = mod;

package/dist/_modules/custom.mjs

@@ -0,0 +1,20 @@
+/** Meta-module that runs custom modules */ const mod = {
+    default: function custom(tree, options, customModules) {
+        if (!customModules) {
+            return tree;
+        }
+        if (!Array.isArray(customModules)) {
+            customModules = [
+                customModules
+            ];
+        }
+        customModules.forEach((customModule)=>{
+            if (customModule) {
+                tree = customModule(tree, options);
+            }
+        });
+        return tree;
+    }
+};
+
+export { mod as default };

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

@@ -0,0 +1,38 @@
+Object.defineProperty(exports, '__esModule', { value: true });
+
+var collapseAttributeWhitespace_js = require('./collapseAttributeWhitespace.js');
+
+/** Deduplicate values inside list-like attributes (e.g. class, rel) */ const mod = {
+    onAttrs () {
+        return (attrs)=>{
+            const newAttrs = attrs;
+            Object.keys(attrs).forEach((attrName)=>{
+                if (!collapseAttributeWhitespace_js.attributesWithLists.has(attrName)) {
+                    return;
+                }
+                if (typeof attrs[attrName] !== 'string') {
+                    return;
+                }
+                const attrValues = attrs[attrName].split(/\s/);
+                const uniqeAttrValues = new Set();
+                const deduplicatedAttrValues = [];
+                attrValues.forEach((attrValue)=>{
+                    if (!attrValue) {
+                        // Keep whitespaces
+                        deduplicatedAttrValues.push('');
+                        return;
+                    }
+                    if (uniqeAttrValues.has(attrValue)) {
+                        return;
+                    }
+                    deduplicatedAttrValues.push(attrValue);
+                    uniqeAttrValues.add(attrValue);
+                });
+                newAttrs[attrName] = deduplicatedAttrValues.join(' ');
+            });
+            return newAttrs;
+        };
+    }
+};
+
+exports.default = mod;

package/dist/_modules/deduplicateAttributeValues.mjs

@@ -0,0 +1,36 @@
+import { attributesWithLists } from './collapseAttributeWhitespace.mjs';
+
+/** Deduplicate values inside list-like attributes (e.g. class, rel) */ const mod = {
+    onAttrs () {
+        return (attrs)=>{
+            const newAttrs = attrs;
+            Object.keys(attrs).forEach((attrName)=>{
+                if (!attributesWithLists.has(attrName)) {
+                    return;
+                }
+                if (typeof attrs[attrName] !== 'string') {
+                    return;
+                }
+                const attrValues = attrs[attrName].split(/\s/);
+                const uniqeAttrValues = new Set();
+                const deduplicatedAttrValues = [];
+                attrValues.forEach((attrValue)=>{
+                    if (!attrValue) {
+                        // Keep whitespaces
+                        deduplicatedAttrValues.push('');
+                        return;
+                    }
+                    if (uniqeAttrValues.has(attrValue)) {
+                        return;
+                    }
+                    deduplicatedAttrValues.push(attrValue);
+                    uniqeAttrValues.add(attrValue);
+                });
+                newAttrs[attrName] = deduplicatedAttrValues.join(' ');
+            });
+            return newAttrs;
+        };
+    }
+};
+
+export { mod as default };

package/dist/_modules/example.d.mts

@@ -0,0 +1,59 @@
+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>;
+};
+
+interface ModuleOptions {
+}
+declare const mod: HtmlnanoModule<ModuleOptions>;
+
+export { mod as default };
+export type { ModuleOptions };

package/dist/_modules/example.d.ts

@@ -0,0 +1,59 @@
+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>;
+};
+
+interface ModuleOptions {
+}
+declare const mod: HtmlnanoModule<ModuleOptions>;
+
+export { mod as default };
+export type { ModuleOptions };

package/dist/_modules/example.js

@@ -0,0 +1,67 @@
+Object.defineProperty(exports, '__esModule', { value: true });
+
+/**
+ * It is an example htmlnano module.
+ */ const mod = {
+    /**
+     * Modify attributes of node. Optional.
+     *
+     * @param {Partial<import('../types').HtmlnanoOptions>} options - Options that were passed to htmlnano
+     * @param {ModuleOptions} moduleOptions — Module options. For most modules this is just "true" (indication that the module was enabled)
+     * @return {Function} - Return a function that takes attribute object and the node (for the context), and returns the modified attribute object
+     */ onAttrs (options, moduleOptions) {
+        // you can run some init operation here
+        return (attrs, node)=>{
+            // You can modify "attrs" based on "node"
+            const newAttrs = {
+                ...attrs
+            };
+            return newAttrs; // ... then return the modified attrs
+        };
+    },
+    /**
+     * Modify content of node. Optional.
+     *
+     * @param {Partial<import('../types').HtmlnanoOptions>} options - Options that were passed to htmlnano
+     * @param {ModuleOptions} moduleOptions — Module options. For most modules this is just "true" (indication that the module was enabled)
+     * @return {Function} - Return a function that takes contents (an array of node and string) and the node (for the context), and returns the modified content array.
+     */ onContent (options, moduleOptions) {
+        // you can run some init operation here
+        return (content, node)=>{
+            // Same goes the "content"
+            return content; // ... return modified content here
+        };
+    },
+    /**
+     * It is possible to modify entire node as well. Optional.
+     * @param {Partial<import('../types').HtmlnanoOptions>} options - Options that were passed to htmlnano
+     * @param {ModuleOptions} moduleOptions — Module options. For most modules this is just "true" (indication that the module was enabled)
+     * @return {Function} - Return a function that takes the node, and returns the new, modified node.
+     */ onNode (options, moduleOptions) {
+        // you can run some init operation here
+        return (node)=>{
+            return node; // ... return new node here
+        };
+    },
+    /**
+     * If you need to access the entire tree (for context like previous and next nodes, parent nodes, etc.)
+     * Modify the entire tree. Optional.
+     *
+     * @param {import('../types').PostHTMLTreeLike} tree - PostHTML tree (https://github.com/posthtml/posthtml/blob/master/README.md)
+     * @param {Partial<import('../types').HtmlnanoOptions>} options - Options that were passed to htmlnano
+     * @param {ModuleOptions} moduleOptions — Module options. For most modules this is just "true" (indication that the module was enabled)
+     * @return {object | Promise} - Return the modified tree.
+     */ default (tree, moduleOptions) {
+        // Module filename (example.es6), exported default function name (example),
+        // and test filename (example.js) must be the same.
+        // You can traverse the tree...
+        tree.walk((node)=>{
+            // ...and make some minifications
+            return node;
+        });
+        // At the end you must return the tree
+        return tree;
+    }
+};
+
+exports.default = mod;

package/dist/_modules/example.mjs

@@ -0,0 +1,65 @@
+/**
+ * It is an example htmlnano module.
+ */ const mod = {
+    /**
+     * Modify attributes of node. Optional.
+     *
+     * @param {Partial<import('../types').HtmlnanoOptions>} options - Options that were passed to htmlnano
+     * @param {ModuleOptions} moduleOptions — Module options. For most modules this is just "true" (indication that the module was enabled)
+     * @return {Function} - Return a function that takes attribute object and the node (for the context), and returns the modified attribute object
+     */ onAttrs (options, moduleOptions) {
+        // you can run some init operation here
+        return (attrs, node)=>{
+            // You can modify "attrs" based on "node"
+            const newAttrs = {
+                ...attrs
+            };
+            return newAttrs; // ... then return the modified attrs
+        };
+    },
+    /**
+     * Modify content of node. Optional.
+     *
+     * @param {Partial<import('../types').HtmlnanoOptions>} options - Options that were passed to htmlnano
+     * @param {ModuleOptions} moduleOptions — Module options. For most modules this is just "true" (indication that the module was enabled)
+     * @return {Function} - Return a function that takes contents (an array of node and string) and the node (for the context), and returns the modified content array.
+     */ onContent (options, moduleOptions) {
+        // you can run some init operation here
+        return (content, node)=>{
+            // Same goes the "content"
+            return content; // ... return modified content here
+        };
+    },
+    /**
+     * It is possible to modify entire node as well. Optional.
+     * @param {Partial<import('../types').HtmlnanoOptions>} options - Options that were passed to htmlnano
+     * @param {ModuleOptions} moduleOptions — Module options. For most modules this is just "true" (indication that the module was enabled)
+     * @return {Function} - Return a function that takes the node, and returns the new, modified node.
+     */ onNode (options, moduleOptions) {
+        // you can run some init operation here
+        return (node)=>{
+            return node; // ... return new node here
+        };
+    },
+    /**
+     * If you need to access the entire tree (for context like previous and next nodes, parent nodes, etc.)
+     * Modify the entire tree. Optional.
+     *
+     * @param {import('../types').PostHTMLTreeLike} tree - PostHTML tree (https://github.com/posthtml/posthtml/blob/master/README.md)
+     * @param {Partial<import('../types').HtmlnanoOptions>} options - Options that were passed to htmlnano
+     * @param {ModuleOptions} moduleOptions — Module options. For most modules this is just "true" (indication that the module was enabled)
+     * @return {object | Promise} - Return the modified tree.
+     */ default (tree, moduleOptions) {
+        // Module filename (example.es6), exported default function name (example),
+        // and test filename (example.js) must be the same.
+        // You can traverse the tree...
+        tree.walk((node)=>{
+            // ...and make some minifications
+            return node;
+        });
+        // At the end you must return the tree
+        return tree;
+    }
+};
+
+export { mod as default };

package/dist/_modules/mergeScripts.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/mergeScripts.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 };