htmlnano 2.1.1 → 2.1.3

package/{lib/modules → dist/_modules}/removeRedundantAttributes.mjs

@@ -1,5 +1,5 @@
 // https://developer.mozilla.org/en-US/docs/Web/HTTP/Basics_of_HTTP/MIME_types#JavaScript_types
-export const redundantScriptTypes = new Set([
+const redundantScriptTypes = new Set([
     'application/javascript',
     'application/ecmascript',
     'application/x-ecmascript',
@@ -17,57 +17,51 @@ export const redundantScriptTypes = new Set([
     'text/x-ecmascript',
     'text/x-javascript'
 ]);
-
 // https://html.spec.whatwg.org/multipage/common-microsyntaxes.html#missing-value-default
 const missingValueDefaultAttributes = {
-    'form': {
-        'method': 'get'
+    form: {
+        method: 'get'
     },
-
     input: {
         type: 'text'
     },
-
     button: {
         // https://html.spec.whatwg.org/multipage/form-elements.html#attr-button-type
         type: 'submit'
     },
-
-    'script': {
-        'language': 'javascript',
-        'type': attrs => {
-            for (const [attrName, attrValue] of Object.entries(attrs)) {
+    script: {
+        language: 'javascript',
+        type: (attrs)=>{
+            for (const [attrName, attrValue] of Object.entries(attrs)){
                 if (attrName.toLowerCase() !== 'type') {
                     continue;
                 }
-
-                return redundantScriptTypes.has(attrValue);
+                if (typeof attrValue === 'string') {
+                    return redundantScriptTypes.has(attrValue);
+                }
+                return false;
             }
-
             return false;
         },
         // Remove attribute if the function returns false
-        'charset': attrs => {
+        charset: (attrs)=>{
             // The charset attribute only really makes sense on “external” SCRIPT elements:
             // http://perfectionkills.com/optimizing-html/#8_script_charset
             return !attrs.src;
         }
     },
-
-    'style': {
-        'media': 'all',
-        'type': 'text/css'
+    style: {
+        media: 'all',
+        type: 'text/css'
     },
-
-    'link': {
+    link: {
         media: 'all',
-        'type': attrs => {
+        type: (attrs)=>{
             // https://html.spec.whatwg.org/multipage/links.html#link-type-stylesheet
             let isRelStyleSheet = false;
             let isTypeTextCSS = false;
-
             if (attrs) {
-                for (const [attrName, attrValue] of Object.entries(attrs)) {
+                for (const [attrName, attrValue] of Object.entries(attrs)){
                     if (attrName.toLowerCase() === 'rel' && attrValue === 'stylesheet') {
                         isRelStyleSheet = true;
                     }
@@ -76,66 +70,56 @@ const missingValueDefaultAttributes = {
                     }
                 }
             }
-
             // Only "text/css" is redudant for link[rel=stylesheet]. Otherwise "type" shouldn't be removed
             return isRelStyleSheet && isTypeTextCSS;
         }
     },
-
     // See: https://html.spec.whatwg.org/#lazy-loading-attributes
     img: {
-        'loading': 'eager',
+        loading: 'eager',
         // https://html.spec.whatwg.org/multipage/embedded-content.html#dom-img-decoding
         decoding: 'auto'
     },
     iframe: {
-        'loading': 'eager'
+        loading: 'eager'
     },
-
     // https://html.spec.whatwg.org/multipage/media.html#htmltrackelement
     track: {
         kind: 'subtitles'
     },
-
     textarea: {
         // https://html.spec.whatwg.org/multipage/form-elements.html#dom-textarea-wrap
         wrap: 'soft'
     },
-
     area: {
         // https://html.spec.whatwg.org/multipage/image-maps.html#attr-area-shape
         shape: 'rect'
     }
 };
-
 const tagsHaveMissingValueDefaultAttributes = new Set(Object.keys(missingValueDefaultAttributes));
-
-/** Removes redundant attributes */
-export function onAttrs() {
-    return (attrs, node) => {
-        if (!node.tag) return attrs;
-
-        const newAttrs = attrs;
-
-        if (tagsHaveMissingValueDefaultAttributes.has(node.tag)) {
-            const tagRedundantAttributes = missingValueDefaultAttributes[node.tag];
-
-            for (const redundantAttributeName of Object.keys(tagRedundantAttributes)) {
-                let tagRedundantAttributeValue = tagRedundantAttributes[redundantAttributeName];
-                let isRemove = false;
-
-                if (typeof tagRedundantAttributeValue === 'function') {
-                    isRemove = tagRedundantAttributeValue(attrs);
-                } else if (attrs[redundantAttributeName] === tagRedundantAttributeValue) {
-                    isRemove = true;
-                }
-
-                if (isRemove) {
-                    delete newAttrs[redundantAttributeName];
+/** Removes redundant attributes */ const mod = {
+    onAttrs () {
+        return (attrs, node)=>{
+            if (!node.tag) return attrs;
+            const newAttrs = attrs;
+            if (tagsHaveMissingValueDefaultAttributes.has(node.tag)) {
+                const tagRedundantAttributes = missingValueDefaultAttributes[node.tag];
+                for (const redundantAttributeName of Object.keys(tagRedundantAttributes)){
+                    const tagRedundantAttributeValue = tagRedundantAttributes[redundantAttributeName];
+                    let isRemove = false;
+                    if (typeof tagRedundantAttributeValue === 'function') {
+                        isRemove = tagRedundantAttributeValue(attrs);
+                    } else if (attrs[redundantAttributeName] === tagRedundantAttributeValue) {
+                        isRemove = true;
+                    }
+                    if (isRemove) {
+                        delete newAttrs[redundantAttributeName];
+                    }
                 }
             }
-        }
+            return newAttrs;
+        };
+    }
+};
 
-        return newAttrs;
-    };
-}
+export { mod as default, redundantScriptTypes };

package/dist/_modules/removeUnusedCss.d.mts

@@ -0,0 +1,60 @@
+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 RemoveUnusedCssOptions {
+    tool?: 'purgeCSS' | 'uncss';
+}
+declare const mod: HtmlnanoModule<RemoveUnusedCssOptions>;
+
+export { mod as default };
+export type { RemoveUnusedCssOptions };

package/dist/_modules/removeUnusedCss.d.ts

@@ -0,0 +1,60 @@
+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 RemoveUnusedCssOptions {
+    tool?: 'purgeCSS' | 'uncss';
+}
+declare const mod: HtmlnanoModule<RemoveUnusedCssOptions>;
+
+export { mod as default };
+export type { RemoveUnusedCssOptions };

package/dist/_modules/removeUnusedCss.js

@@ -0,0 +1,134 @@
+Object.defineProperty(exports, '__esModule', { value: true });
+
+var helpers_js = require('../helpers.js');
+
+// These options must be set and shouldn't be overriden to ensure uncss doesn't look at linked stylesheets.
+const uncssOptions = {
+    ignoreSheets: [
+        /\s*/
+    ],
+    stylesheets: []
+};
+function processStyleNodeUnCSS(html, styleNode, uncssOptions, uncss) {
+    const css = helpers_js.extractCssFromStyleNode(styleNode);
+    // eslint-disable-next-line @typescript-eslint/no-unsafe-argument -- uncss no types
+    return runUncss(html, css, uncssOptions, uncss).then((css)=>{
+        // uncss may have left some style tags empty
+        if (css.trim().length === 0) {
+            // @ts-expect-error -- explicitly remove the tag
+            styleNode.tag = false;
+            styleNode.content = [];
+            return;
+        }
+        styleNode.content = [
+            css
+        ];
+    });
+}
+function runUncss(html, css, userOptions, uncss) {
+    if (typeof userOptions !== 'object') {
+        userOptions = {};
+    }
+    const options = {
+        ...userOptions,
+        ...uncssOptions
+    };
+    return new Promise((resolve, reject)=>{
+        // eslint-disable-next-line @typescript-eslint/no-explicit-any, @typescript-eslint/no-unsafe-member-access -- we dont have uncss types
+        options.raw = css;
+        uncss(html, options, (error, output)=>{
+            if (error) {
+                reject(error);
+                return;
+            }
+            resolve(output);
+        });
+    });
+}
+const purgeFromHtml = function(tree) {
+    // content is not used as we can directly used the parsed HTML,
+    // making the process faster
+    const selectors = [];
+    tree.walk((node)=>{
+        const classes = node.attrs && node.attrs.class && node.attrs.class.split(' ') || [];
+        const ids = node.attrs && node.attrs.id && node.attrs.id.split(' ') || [];
+        selectors.push(...classes, ...ids);
+        if (node.tag) {
+            selectors.push(node.tag);
+        }
+        return node;
+    });
+    return ()=>selectors;
+};
+function processStyleNodePurgeCSS(tree, styleNode, purgecssOptions, purgecss) {
+    const css = helpers_js.extractCssFromStyleNode(styleNode);
+    return runPurgecss(tree, css, purgecssOptions, purgecss).then((css)=>{
+        if (css.trim().length === 0) {
+            // @ts-expect-error -- explicitly remove the tag
+            styleNode.tag = false;
+            styleNode.content = [];
+            return;
+        }
+        styleNode.content = [
+            css
+        ];
+    });
+}
+function runPurgecss(tree, css, userOptions, purgecss) {
+    if (typeof userOptions !== 'object') {
+        userOptions = {};
+    }
+    const options = {
+        ...userOptions,
+        content: [
+            {
+                raw: tree.render(),
+                extension: 'html'
+            }
+        ],
+        css: [
+            {
+                raw: css,
+                // @ts-expect-error -- old purgecss options
+                extension: 'css'
+            }
+        ],
+        extractors: [
+            {
+                extractor: purgeFromHtml(tree),
+                extensions: [
+                    'html'
+                ]
+            }
+        ]
+    };
+    return new purgecss.PurgeCSS().purge(options).then((result)=>{
+        return result[0].css;
+    });
+}
+/** Remove unused CSS */ const mod = {
+    async default (tree, options, userOptions) {
+        const promises = [];
+        let html;
+        const purgecss = await helpers_js.optionalImport('purgecss');
+        const uncss = await helpers_js.optionalImport('uncss');
+        tree.walk((node)=>{
+            if (helpers_js.isStyleNode(node)) {
+                if (userOptions.tool === 'purgeCSS') {
+                    if (purgecss) {
+                        promises.push(processStyleNodePurgeCSS(tree, node, userOptions, purgecss));
+                    }
+                } else {
+                    if (uncss) {
+                        html != null ? html : html = tree.render(tree);
+                        promises.push(processStyleNodeUnCSS(html, node, userOptions, uncss));
+                    }
+                }
+            }
+            return node;
+        });
+        return Promise.all(promises).then(()=>tree);
+    }
+};
+
+exports.default = mod;

package/dist/_modules/removeUnusedCss.mjs

@@ -0,0 +1,132 @@
+import { optionalImport, isStyleNode, extractCssFromStyleNode } from '../helpers.mjs';
+
+// These options must be set and shouldn't be overriden to ensure uncss doesn't look at linked stylesheets.
+const uncssOptions = {
+    ignoreSheets: [
+        /\s*/
+    ],
+    stylesheets: []
+};
+function processStyleNodeUnCSS(html, styleNode, uncssOptions, uncss) {
+    const css = extractCssFromStyleNode(styleNode);
+    // eslint-disable-next-line @typescript-eslint/no-unsafe-argument -- uncss no types
+    return runUncss(html, css, uncssOptions, uncss).then((css)=>{
+        // uncss may have left some style tags empty
+        if (css.trim().length === 0) {
+            // @ts-expect-error -- explicitly remove the tag
+            styleNode.tag = false;
+            styleNode.content = [];
+            return;
+        }
+        styleNode.content = [
+            css
+        ];
+    });
+}
+function runUncss(html, css, userOptions, uncss) {
+    if (typeof userOptions !== 'object') {
+        userOptions = {};
+    }
+    const options = {
+        ...userOptions,
+        ...uncssOptions
+    };
+    return new Promise((resolve, reject)=>{
+        // eslint-disable-next-line @typescript-eslint/no-explicit-any, @typescript-eslint/no-unsafe-member-access -- we dont have uncss types
+        options.raw = css;
+        uncss(html, options, (error, output)=>{
+            if (error) {
+                reject(error);
+                return;
+            }
+            resolve(output);
+        });
+    });
+}
+const purgeFromHtml = function(tree) {
+    // content is not used as we can directly used the parsed HTML,
+    // making the process faster
+    const selectors = [];
+    tree.walk((node)=>{
+        const classes = node.attrs && node.attrs.class && node.attrs.class.split(' ') || [];
+        const ids = node.attrs && node.attrs.id && node.attrs.id.split(' ') || [];
+        selectors.push(...classes, ...ids);
+        if (node.tag) {
+            selectors.push(node.tag);
+        }
+        return node;
+    });
+    return ()=>selectors;
+};
+function processStyleNodePurgeCSS(tree, styleNode, purgecssOptions, purgecss) {
+    const css = extractCssFromStyleNode(styleNode);
+    return runPurgecss(tree, css, purgecssOptions, purgecss).then((css)=>{
+        if (css.trim().length === 0) {
+            // @ts-expect-error -- explicitly remove the tag
+            styleNode.tag = false;
+            styleNode.content = [];
+            return;
+        }
+        styleNode.content = [
+            css
+        ];
+    });
+}
+function runPurgecss(tree, css, userOptions, purgecss) {
+    if (typeof userOptions !== 'object') {
+        userOptions = {};
+    }
+    const options = {
+        ...userOptions,
+        content: [
+            {
+                raw: tree.render(),
+                extension: 'html'
+            }
+        ],
+        css: [
+            {
+                raw: css,
+                // @ts-expect-error -- old purgecss options
+                extension: 'css'
+            }
+        ],
+        extractors: [
+            {
+                extractor: purgeFromHtml(tree),
+                extensions: [
+                    'html'
+                ]
+            }
+        ]
+    };
+    return new purgecss.PurgeCSS().purge(options).then((result)=>{
+        return result[0].css;
+    });
+}
+/** Remove unused CSS */ const mod = {
+    async default (tree, options, userOptions) {
+        const promises = [];
+        let html;
+        const purgecss = await optionalImport('purgecss');
+        const uncss = await optionalImport('uncss');
+        tree.walk((node)=>{
+            if (isStyleNode(node)) {
+                if (userOptions.tool === 'purgeCSS') {
+                    if (purgecss) {
+                        promises.push(processStyleNodePurgeCSS(tree, node, userOptions, purgecss));
+                    }
+                } else {
+                    if (uncss) {
+                        html != null ? html : html = tree.render(tree);
+                        promises.push(processStyleNodeUnCSS(html, node, userOptions, uncss));
+                    }
+                }
+            }
+            return node;
+        });
+        return Promise.all(promises).then(()=>tree);
+    }
+};
+
+export { mod as default };

package/dist/_modules/sortAttributes.d.mts

@@ -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 ValidOptions = 'alphabetical' | 'frequency';
+declare const mod: HtmlnanoModule<boolean | ValidOptions>;
+
+export { mod as default };

package/dist/_modules/sortAttributes.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 ValidOptions = 'alphabetical' | 'frequency';
+declare const mod: HtmlnanoModule<boolean | ValidOptions>;
+
+export { mod as default };