htmlnano 2.1.2 → 2.1.4

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

@@ -48,7 +48,6 @@ const htmlBooleanAttributes = new Set([
     'typemustmatch',
     'visible'
 ]);
-
 const amphtmlBooleanAttributes = new Set([
     '⚡',
     'amp',
@@ -56,12 +55,10 @@ const amphtmlBooleanAttributes = new Set([
     'amp4ads',
     '⚡4email',
     'amp4email',
-
     'amp-custom',
     'amp-boilerplate',
     'amp4ads-boilerplate',
     'amp4email-boilerplate',
-
     'allow-blocked-ranges',
     'amp-access-hide',
     'amp-access-template',
@@ -105,7 +102,6 @@ const amphtmlBooleanAttributes = new Set([
     'subscriptions-actions',
     'subscriptions-dialog'
 ]);
-
 const missingValueDefaultEmptyStringAttributes = {
     // https://html.spec.whatwg.org/#attr-media-preload
     audio: {
@@ -115,61 +111,47 @@ const missingValueDefaultEmptyStringAttributes = {
         preload: 'auto'
     }
 };
-
 const tagsHasMissingValueDefaultEmptyStringAttributes = new Set(Object.keys(missingValueDefaultEmptyStringAttributes));
-
-export function onAttrs(options, moduleOptions) {
-    return (attrs, node) => {
-        if (!node.tag) return attrs;
-
-        const newAttrs = attrs;
-
-        if (tagsHasMissingValueDefaultEmptyStringAttributes.has(node.tag)) {
-            const tagAttributesCanBeReplacedWithEmptyString = missingValueDefaultEmptyStringAttributes[node.tag];
-
-            for (const attributesCanBeReplacedWithEmptyString of Object.keys(tagAttributesCanBeReplacedWithEmptyString)) {
-                if (
-                    Object.prototype.hasOwnProperty.call(attrs, attributesCanBeReplacedWithEmptyString)
-                    && attrs[attributesCanBeReplacedWithEmptyString] === tagAttributesCanBeReplacedWithEmptyString[attributesCanBeReplacedWithEmptyString]
-                ) {
-                    attrs[attributesCanBeReplacedWithEmptyString] = true;
+const mod = {
+    onAttrs (options, moduleOptions) {
+        return (attrs, node)=>{
+            if (!node.tag) return attrs;
+            const newAttrs = attrs;
+            if (tagsHasMissingValueDefaultEmptyStringAttributes.has(node.tag)) {
+                const tagAttributesCanBeReplacedWithEmptyString = missingValueDefaultEmptyStringAttributes[node.tag];
+                for (const attributesCanBeReplacedWithEmptyString of Object.keys(tagAttributesCanBeReplacedWithEmptyString)){
+                    if (attributesCanBeReplacedWithEmptyString in attrs && attributesCanBeReplacedWithEmptyString in tagAttributesCanBeReplacedWithEmptyString && attrs[attributesCanBeReplacedWithEmptyString] === tagAttributesCanBeReplacedWithEmptyString[attributesCanBeReplacedWithEmptyString]) {
+                        attrs[attributesCanBeReplacedWithEmptyString] = true;
+                    }
                 }
             }
-        }
-
-        for (const attrName of Object.keys(attrs)) {
-            if (attrName === 'visible' && node.tag.startsWith('a-')) {
-                continue;
-            }
-
-            if (htmlBooleanAttributes.has(attrName)) {
-                newAttrs[attrName] = true;
-            }
-
-            // Fast path optimization.
-            // The rest of tranformations are only for string type attrValue.
-            if (typeof newAttrs[attrName] !== 'string') continue;
-
-            if (moduleOptions.amphtml && amphtmlBooleanAttributes.has(attrName) && attrs[attrName] === '') {
-                newAttrs[attrName] = true;
-            }
-            // https://html.spec.whatwg.org/#a-quick-introduction-to-html
-            // The value, along with the "=" character, can be omitted altogether if the value is the empty string.
-            if (attrs[attrName] === '') {
-                newAttrs[attrName] = true;
-            }
-
-            // collapse crossorigin attributes
-            // Specification: https://html.spec.whatwg.org/multipage/urls-and-fetching.html#cors-settings-attributes
-            if (
-                attrName.toLowerCase() === 'crossorigin' && (
-                    attrs[attrName] === 'anonymous'
-                )
-            ) {
-                newAttrs[attrName] = true;
+            for (const attrName of Object.keys(attrs)){
+                if (attrName === 'visible' && node.tag.startsWith('a-')) {
+                    continue;
+                }
+                if (htmlBooleanAttributes.has(attrName)) {
+                    newAttrs[attrName] = true;
+                }
+                // Fast path optimization.
+                // The rest of tranformations are only for string type attrValue.
+                if (typeof newAttrs[attrName] !== 'string') continue;
+                if (moduleOptions.amphtml && amphtmlBooleanAttributes.has(attrName) && attrs[attrName] === '') {
+                    newAttrs[attrName] = true;
+                }
+                // https://html.spec.whatwg.org/#a-quick-introduction-to-html
+                // The value, along with the "=" character, can be omitted altogether if the value is the empty string.
+                if (attrs[attrName] === '') {
+                    newAttrs[attrName] = true;
+                }
+                // collapse crossorigin attributes
+                // Specification: https://html.spec.whatwg.org/multipage/urls-and-fetching.html#cors-settings-attributes
+                if (attrName.toLowerCase() === 'crossorigin' && attrs[attrName] === 'anonymous') {
+                    newAttrs[attrName] = true;
+                }
             }
-        }
+            return newAttrs;
+        };
+    }
+};
 
-        return newAttrs;
-    };
-}
+export { mod as default };

package/dist/_modules/collapseWhitespace.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 CollapseType = 'all' | 'aggressive' | 'conservative';
+declare const mod: HtmlnanoModule<CollapseType>;
+
+export { mod as default };

package/dist/_modules/collapseWhitespace.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 CollapseType = 'all' | 'aggressive' | 'conservative';
+declare const mod: HtmlnanoModule<CollapseType>;
+
+export { mod as default };

package/dist/_modules/collapseWhitespace.js

@@ -0,0 +1,172 @@
+Object.defineProperty(exports, '__esModule', { value: true });
+
+var helpers_js = require('../helpers.js');
+
+const noWhitespaceCollapseElements = new Set([
+    'script',
+    'style',
+    'pre',
+    'textarea'
+]);
+const noTrimWhitespacesArroundElements = new Set([
+    // non-empty tags that will maintain whitespace around them
+    'a',
+    'abbr',
+    'acronym',
+    'b',
+    'bdi',
+    'bdo',
+    'big',
+    'button',
+    'cite',
+    'code',
+    'del',
+    'dfn',
+    'em',
+    'font',
+    'i',
+    'ins',
+    'kbd',
+    'label',
+    'mark',
+    'math',
+    'nobr',
+    'object',
+    'q',
+    'rp',
+    'rt',
+    'rtc',
+    'ruby',
+    's',
+    'samp',
+    'select',
+    'small',
+    'span',
+    'strike',
+    'strong',
+    'sub',
+    'sup',
+    'svg',
+    'textarea',
+    'time',
+    'tt',
+    'u',
+    'var',
+    // self-closing tags that will maintain whitespace around them
+    'comment',
+    'img',
+    'input',
+    'wbr'
+]);
+const noTrimWhitespacesInsideElements = new Set([
+    // non-empty tags that will maintain whitespace within them
+    'a',
+    'abbr',
+    'acronym',
+    'b',
+    'big',
+    'del',
+    'em',
+    'font',
+    'i',
+    'ins',
+    'kbd',
+    'mark',
+    'nobr',
+    'rp',
+    's',
+    'samp',
+    'small',
+    'span',
+    'strike',
+    'strong',
+    'sub',
+    'sup',
+    'time',
+    'tt',
+    'u',
+    'var'
+]);
+const startsWithWhitespacePattern = /^\s/;
+const endsWithWhitespacePattern = /\s$/;
+// See https://infra.spec.whatwg.org/#strip-and-collapse-ascii-whitespace and https://infra.spec.whatwg.org/#ascii-whitespace
+const multipleWhitespacePattern = /[\t\n\f\r ]+/g;
+const NONE = '';
+const SINGLE_SPACE = ' ';
+const validOptions = [
+    'all',
+    'aggressive',
+    'conservative'
+];
+function collapseWhitespace(tree, options, collapseType, parent) {
+    collapseType = validOptions.includes(collapseType) ? collapseType : 'conservative';
+    tree.forEach((node, index)=>{
+        const prevNode = tree[index - 1];
+        const nextNode = tree[index + 1];
+        if (typeof node === 'string') {
+            const parentNodeTag = parent == null ? void 0 : parent.node.tag;
+            const isTopLevel = parentNodeTag == null || parentNodeTag === 'html' || parentNodeTag === 'head';
+            const shouldTrim = isTopLevel || collapseType === 'all' || collapseType === 'aggressive';
+            node = collapseRedundantWhitespaces(node, collapseType, shouldTrim, parent, prevNode, nextNode);
+        } else if (node.tag) {
+            var _node_content;
+            const isAllowCollapseWhitespace = !noWhitespaceCollapseElements.has(node.tag);
+            if (isAllowCollapseWhitespace && ((_node_content = node.content) == null ? void 0 : _node_content.length)) {
+                node.content = collapseWhitespace(node.content, options, collapseType, {
+                    node,
+                    prevNode});
+            }
+        }
+        tree[index] = node;
+    });
+    return tree;
+}
+function collapseRedundantWhitespaces(text, collapseType, shouldTrim = false, parent, prevNode, nextNode) {
+    if (!text || text.length === 0) {
+        return NONE;
+    }
+    if (!helpers_js.isComment(text)) {
+        text = text.replace(multipleWhitespacePattern, SINGLE_SPACE);
+    }
+    if (shouldTrim) {
+        // either all or top level, trim all
+        if (collapseType === 'all' || collapseType === 'conservative') {
+            return text.trim();
+        }
+        if (typeof parent !== 'object' || !(parent == null ? void 0 : parent.node.tag) || !noTrimWhitespacesInsideElements.has(parent.node.tag)) {
+            if (// It is the first child node of the parent
+            !prevNode || typeof prevNode === 'object' && prevNode.tag && !noTrimWhitespacesArroundElements.has(prevNode.tag)) {
+                text = text.trimStart();
+            } else {
+                // previous node is a "no trim whitespaces arround element"
+                if (// but previous node ends with a whitespace
+                typeof prevNode === 'object' && prevNode.content) {
+                    const prevNodeLastContent = prevNode.content[prevNode.content.length - 1];
+                    if (typeof prevNodeLastContent === 'string' && endsWithWhitespacePattern.test(prevNodeLastContent) && (!nextNode // either the current node is the last child of the parent
+                     || // or the next node starts with a white space
+                    typeof nextNode === 'object' && nextNode.content && typeof nextNode.content[0] === 'string' && !startsWithWhitespacePattern.test(nextNode.content[0]))) {
+                        text = text.trimStart();
+                    }
+                }
+            }
+            if (!nextNode || typeof nextNode === 'object' && nextNode.tag && !noTrimWhitespacesArroundElements.has(nextNode.tag)) {
+                text = text.trimEnd();
+            }
+        } else {
+            // now it is a textNode inside a "no trim whitespaces inside elements" node
+            if (!prevNode // it the textnode is the first child of the node
+             && startsWithWhitespacePattern.test(text[0]) // it starts with white space
+             && typeof (parent == null ? void 0 : parent.prevNode) === 'string' // the prev of the node is a textNode as well
+             && endsWithWhitespacePattern.test(parent.prevNode[parent.prevNode.length - 1]) // that prev is ends with a white
+            ) {
+                text = text.trimStart();
+            }
+        }
+    }
+    return text;
+}
+const mod = {
+    default: collapseWhitespace
+};
+
+exports.default = mod;

package/dist/_modules/collapseWhitespace.mjs

@@ -0,0 +1,170 @@
+import { isComment } from '../helpers.mjs';
+
+const noWhitespaceCollapseElements = new Set([
+    'script',
+    'style',
+    'pre',
+    'textarea'
+]);
+const noTrimWhitespacesArroundElements = new Set([
+    // non-empty tags that will maintain whitespace around them
+    'a',
+    'abbr',
+    'acronym',
+    'b',
+    'bdi',
+    'bdo',
+    'big',
+    'button',
+    'cite',
+    'code',
+    'del',
+    'dfn',
+    'em',
+    'font',
+    'i',
+    'ins',
+    'kbd',
+    'label',
+    'mark',
+    'math',
+    'nobr',
+    'object',
+    'q',
+    'rp',
+    'rt',
+    'rtc',
+    'ruby',
+    's',
+    'samp',
+    'select',
+    'small',
+    'span',
+    'strike',
+    'strong',
+    'sub',
+    'sup',
+    'svg',
+    'textarea',
+    'time',
+    'tt',
+    'u',
+    'var',
+    // self-closing tags that will maintain whitespace around them
+    'comment',
+    'img',
+    'input',
+    'wbr'
+]);
+const noTrimWhitespacesInsideElements = new Set([
+    // non-empty tags that will maintain whitespace within them
+    'a',
+    'abbr',
+    'acronym',
+    'b',
+    'big',
+    'del',
+    'em',
+    'font',
+    'i',
+    'ins',
+    'kbd',
+    'mark',
+    'nobr',
+    'rp',
+    's',
+    'samp',
+    'small',
+    'span',
+    'strike',
+    'strong',
+    'sub',
+    'sup',
+    'time',
+    'tt',
+    'u',
+    'var'
+]);
+const startsWithWhitespacePattern = /^\s/;
+const endsWithWhitespacePattern = /\s$/;
+// See https://infra.spec.whatwg.org/#strip-and-collapse-ascii-whitespace and https://infra.spec.whatwg.org/#ascii-whitespace
+const multipleWhitespacePattern = /[\t\n\f\r ]+/g;
+const NONE = '';
+const SINGLE_SPACE = ' ';
+const validOptions = [
+    'all',
+    'aggressive',
+    'conservative'
+];
+function collapseWhitespace(tree, options, collapseType, parent) {
+    collapseType = validOptions.includes(collapseType) ? collapseType : 'conservative';
+    tree.forEach((node, index)=>{
+        const prevNode = tree[index - 1];
+        const nextNode = tree[index + 1];
+        if (typeof node === 'string') {
+            const parentNodeTag = parent == null ? void 0 : parent.node.tag;
+            const isTopLevel = parentNodeTag == null || parentNodeTag === 'html' || parentNodeTag === 'head';
+            const shouldTrim = isTopLevel || collapseType === 'all' || collapseType === 'aggressive';
+            node = collapseRedundantWhitespaces(node, collapseType, shouldTrim, parent, prevNode, nextNode);
+        } else if (node.tag) {
+            var _node_content;
+            const isAllowCollapseWhitespace = !noWhitespaceCollapseElements.has(node.tag);
+            if (isAllowCollapseWhitespace && ((_node_content = node.content) == null ? void 0 : _node_content.length)) {
+                node.content = collapseWhitespace(node.content, options, collapseType, {
+                    node,
+                    prevNode});
+            }
+        }
+        tree[index] = node;
+    });
+    return tree;
+}
+function collapseRedundantWhitespaces(text, collapseType, shouldTrim = false, parent, prevNode, nextNode) {
+    if (!text || text.length === 0) {
+        return NONE;
+    }
+    if (!isComment(text)) {
+        text = text.replace(multipleWhitespacePattern, SINGLE_SPACE);
+    }
+    if (shouldTrim) {
+        // either all or top level, trim all
+        if (collapseType === 'all' || collapseType === 'conservative') {
+            return text.trim();
+        }
+        if (typeof parent !== 'object' || !(parent == null ? void 0 : parent.node.tag) || !noTrimWhitespacesInsideElements.has(parent.node.tag)) {
+            if (// It is the first child node of the parent
+            !prevNode || typeof prevNode === 'object' && prevNode.tag && !noTrimWhitespacesArroundElements.has(prevNode.tag)) {
+                text = text.trimStart();
+            } else {
+                // previous node is a "no trim whitespaces arround element"
+                if (// but previous node ends with a whitespace
+                typeof prevNode === 'object' && prevNode.content) {
+                    const prevNodeLastContent = prevNode.content[prevNode.content.length - 1];
+                    if (typeof prevNodeLastContent === 'string' && endsWithWhitespacePattern.test(prevNodeLastContent) && (!nextNode // either the current node is the last child of the parent
+                     || // or the next node starts with a white space
+                    typeof nextNode === 'object' && nextNode.content && typeof nextNode.content[0] === 'string' && !startsWithWhitespacePattern.test(nextNode.content[0]))) {
+                        text = text.trimStart();
+                    }
+                }
+            }
+            if (!nextNode || typeof nextNode === 'object' && nextNode.tag && !noTrimWhitespacesArroundElements.has(nextNode.tag)) {
+                text = text.trimEnd();
+            }
+        } else {
+            // now it is a textNode inside a "no trim whitespaces inside elements" node
+            if (!prevNode // it the textnode is the first child of the node
+             && startsWithWhitespacePattern.test(text[0]) // it starts with white space
+             && typeof (parent == null ? void 0 : parent.prevNode) === 'string' // the prev of the node is a textNode as well
+             && endsWithWhitespacePattern.test(parent.prevNode[parent.prevNode.length - 1]) // that prev is ends with a white
+            ) {
+                text = text.trimStart();
+            }
+        }
+    }
+    return text;
+}
+const mod = {
+    default: collapseWhitespace
+};
+
+export { mod as default };

package/dist/_modules/custom.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 CustomModule = (tree: PostHTMLTreeLike, options: Partial<HtmlnanoOptions>) => PostHTMLTreeLike;
+declare const mod: HtmlnanoModule<CustomModule[]>;
+
+export { mod as default };