htmlnano 3.0.0 → 3.2.0

package/dist/_modules/removeEmptyAttributes.d.mts

@@ -2,16 +2,24 @@ import PostHTML from 'posthtml';
 import { MinifyOptions } from 'terser';
 import { Options } from 'cssnano';
 import { Config } from 'svgo';
+import { UserDefinedOptions } from 'purgecss';
 
 type PostHTMLTreeLike = [PostHTML.Node] & PostHTML.NodeAPI & {
     options?: {
         quoteAllAttributes?: boolean | undefined;
+        quoteStyle?: 0 | 1 | 2 | undefined;
+        replaceQuote?: boolean | undefined;
     } | undefined;
     render(): string;
     render(node: PostHTML.Node | PostHTMLTreeLike, renderOptions?: any): string;
 };
 type MaybeArray<T> = T | Array<T>;
 type PostHTMLNodeLike = PostHTML.Node | string;
+type HtmlnanoTemplateRule = {
+    tag: string;
+    attrs?: Record<string, string | boolean | void>;
+};
+type MinifyHtmlTemplateOptions = boolean | HtmlnanoTemplateRule[];
 interface HtmlnanoOptions {
     skipConfigLoading?: boolean;
     configPath?: string;
@@ -27,17 +35,42 @@ interface HtmlnanoOptions {
     mergeStyles?: boolean;
     mergeScripts?: boolean;
     minifyCss?: Options | boolean;
+    minifyHtmlTemplate?: MinifyHtmlTemplateOptions;
     minifyConditionalComments?: boolean;
     minifyJs?: MinifyOptions | boolean;
     minifyJson?: boolean;
+    minifyAttributes?: boolean | {
+        metaContent?: boolean;
+        redundantWhitespaces?: 'safe' | 'agressive' | false;
+    };
     minifySvg?: Config | boolean;
     normalizeAttributeValues?: boolean;
-    removeAttributeQuotes?: boolean;
-    removeComments?: boolean | 'safe' | 'all' | RegExp | ((comment: string) => boolean);
+    removeAttributeQuotes?: boolean | {
+        force?: boolean;
+    };
+    removeComments?: boolean | RegExp | ((comment: string) => boolean) | string;
     removeEmptyAttributes?: boolean;
+    removeEmptyElements?: boolean | {
+        removeWithAttributes?: boolean;
+    };
     removeRedundantAttributes?: boolean;
     removeOptionalTags?: boolean;
-    removeUnusedCss?: boolean;
+    removeUnusedCss?: boolean | ({
+        tool: 'purgeCSS';
+    } & Omit<UserDefinedOptions, 'content' | 'css' | 'extractors'>) | {
+        banner?: boolean;
+        csspath?: string;
+        htmlroot?: string;
+        ignore?: (string | RegExp)[];
+        inject?: string;
+        jsdom?: object;
+        media?: string[];
+        report?: boolean;
+        strictSSL?: boolean;
+        timeout?: number;
+        uncssrc?: string;
+        userAgent?: string;
+    };
     sortAttributes?: boolean | 'alphabetical' | 'frequency';
     sortAttributesWithLists?: boolean | 'alphabetical' | 'frequency';
 }

package/dist/_modules/removeEmptyAttributes.d.ts

@@ -2,16 +2,24 @@ import PostHTML from 'posthtml';
 import { MinifyOptions } from 'terser';
 import { Options } from 'cssnano';
 import { Config } from 'svgo';
+import { UserDefinedOptions } from 'purgecss';
 
 type PostHTMLTreeLike = [PostHTML.Node] & PostHTML.NodeAPI & {
     options?: {
         quoteAllAttributes?: boolean | undefined;
+        quoteStyle?: 0 | 1 | 2 | undefined;
+        replaceQuote?: boolean | undefined;
     } | undefined;
     render(): string;
     render(node: PostHTML.Node | PostHTMLTreeLike, renderOptions?: any): string;
 };
 type MaybeArray<T> = T | Array<T>;
 type PostHTMLNodeLike = PostHTML.Node | string;
+type HtmlnanoTemplateRule = {
+    tag: string;
+    attrs?: Record<string, string | boolean | void>;
+};
+type MinifyHtmlTemplateOptions = boolean | HtmlnanoTemplateRule[];
 interface HtmlnanoOptions {
     skipConfigLoading?: boolean;
     configPath?: string;
@@ -27,17 +35,42 @@ interface HtmlnanoOptions {
     mergeStyles?: boolean;
     mergeScripts?: boolean;
     minifyCss?: Options | boolean;
+    minifyHtmlTemplate?: MinifyHtmlTemplateOptions;
     minifyConditionalComments?: boolean;
     minifyJs?: MinifyOptions | boolean;
     minifyJson?: boolean;
+    minifyAttributes?: boolean | {
+        metaContent?: boolean;
+        redundantWhitespaces?: 'safe' | 'agressive' | false;
+    };
     minifySvg?: Config | boolean;
     normalizeAttributeValues?: boolean;
-    removeAttributeQuotes?: boolean;
-    removeComments?: boolean | 'safe' | 'all' | RegExp | ((comment: string) => boolean);
+    removeAttributeQuotes?: boolean | {
+        force?: boolean;
+    };
+    removeComments?: boolean | RegExp | ((comment: string) => boolean) | string;
     removeEmptyAttributes?: boolean;
+    removeEmptyElements?: boolean | {
+        removeWithAttributes?: boolean;
+    };
     removeRedundantAttributes?: boolean;
     removeOptionalTags?: boolean;
-    removeUnusedCss?: boolean;
+    removeUnusedCss?: boolean | ({
+        tool: 'purgeCSS';
+    } & Omit<UserDefinedOptions, 'content' | 'css' | 'extractors'>) | {
+        banner?: boolean;
+        csspath?: string;
+        htmlroot?: string;
+        ignore?: (string | RegExp)[];
+        inject?: string;
+        jsdom?: object;
+        media?: string[];
+        report?: boolean;
+        strictSSL?: boolean;
+        timeout?: number;
+        uncssrc?: string;
+        userAgent?: string;
+    };
     sortAttributes?: boolean | 'alphabetical' | 'frequency';
     sortAttributesWithLists?: boolean | 'alphabetical' | 'frequency';
 }

package/dist/_modules/removeEmptyAttributes.js

@@ -67,22 +67,36 @@ const safeToRemoveAttrs = {
         'object',
         'video'
     ],
-    high: 'meter',
-    href: 'link',
-    list: 'input',
-    low: 'meter',
-    manifest: 'html',
+    high: [
+        'meter'
+    ],
+    href: [
+        'link'
+    ],
+    list: [
+        'input'
+    ],
+    low: [
+        'meter'
+    ],
+    manifest: [
+        'html'
+    ],
     max: [
         'meter',
         'progress'
     ],
-    maxLength: [
+    maxlength: [
         'input',
         'textarea'
     ],
-    menu: 'button',
-    min: 'meter',
-    minLength: [
+    menu: [
+        'button'
+    ],
+    min: [
+        'meter'
+    ],
+    minlength: [
         'input',
         'textarea'
     ],
@@ -119,7 +133,9 @@ const safeToRemoveAttrs = {
         'area',
         'link'
     ],
-    rows: 'textarea',
+    rows: [
+        'textarea'
+    ],
     rowspan: [
         'td',
         'th'
@@ -143,7 +159,9 @@ const safeToRemoveAttrs = {
         'track',
         'video'
     ],
-    start: 'ol',
+    start: [
+        'ol'
+    ],
     tabindex: null,
     type: [
         'a',
@@ -180,12 +198,15 @@ const mod = {
             const newAttrs = {
                 ...attrs
             };
+            const tagName = typeof node.tag === 'string' ? node.tag.toLowerCase() : '';
             Object.entries(attrs).forEach(([attrName, attrValue])=>{
-                if (helpers_js.isEventHandler(attrName) || Object.hasOwnProperty.call(safeToRemoveAttrs, attrName) && (safeToRemoveAttrs[attrName] === null || typeof node.tag === 'string' && safeToRemoveAttrs[attrName].includes(node.tag))) {
-                    if (typeof attrValue === 'string') {
-                        if (attrValue === '' || attrValue.trim() === '') {
-                            delete newAttrs[attrName];
-                        }
+                const normalizedAttrName = attrName.toLowerCase();
+                const safeAttr = safeToRemoveAttrs[normalizedAttrName];
+                if (helpers_js.isEventHandler(attrName) || safeAttr !== undefined && (safeAttr === null || tagName && safeAttr.includes(tagName))) {
+                    if (attrValue === null || attrValue === undefined) {
+                        delete newAttrs[attrName];
+                    } else if (typeof attrValue === 'string' && attrValue.trim() === '') {
+                        delete newAttrs[attrName];
                     }
                 }
             });

package/dist/_modules/removeEmptyAttributes.mjs

@@ -65,22 +65,36 @@ const safeToRemoveAttrs = {
         'object',
         'video'
     ],
-    high: 'meter',
-    href: 'link',
-    list: 'input',
-    low: 'meter',
-    manifest: 'html',
+    high: [
+        'meter'
+    ],
+    href: [
+        'link'
+    ],
+    list: [
+        'input'
+    ],
+    low: [
+        'meter'
+    ],
+    manifest: [
+        'html'
+    ],
     max: [
         'meter',
         'progress'
     ],
-    maxLength: [
+    maxlength: [
         'input',
         'textarea'
     ],
-    menu: 'button',
-    min: 'meter',
-    minLength: [
+    menu: [
+        'button'
+    ],
+    min: [
+        'meter'
+    ],
+    minlength: [
         'input',
         'textarea'
     ],
@@ -117,7 +131,9 @@ const safeToRemoveAttrs = {
         'area',
         'link'
     ],
-    rows: 'textarea',
+    rows: [
+        'textarea'
+    ],
     rowspan: [
         'td',
         'th'
@@ -141,7 +157,9 @@ const safeToRemoveAttrs = {
         'track',
         'video'
     ],
-    start: 'ol',
+    start: [
+        'ol'
+    ],
     tabindex: null,
     type: [
         'a',
@@ -178,12 +196,15 @@ const mod = {
             const newAttrs = {
                 ...attrs
             };
+            const tagName = typeof node.tag === 'string' ? node.tag.toLowerCase() : '';
             Object.entries(attrs).forEach(([attrName, attrValue])=>{
-                if (isEventHandler(attrName) || Object.hasOwnProperty.call(safeToRemoveAttrs, attrName) && (safeToRemoveAttrs[attrName] === null || typeof node.tag === 'string' && safeToRemoveAttrs[attrName].includes(node.tag))) {
-                    if (typeof attrValue === 'string') {
-                        if (attrValue === '' || attrValue.trim() === '') {
-                            delete newAttrs[attrName];
-                        }
+                const normalizedAttrName = attrName.toLowerCase();
+                const safeAttr = safeToRemoveAttrs[normalizedAttrName];
+                if (isEventHandler(attrName) || safeAttr !== undefined && (safeAttr === null || tagName && safeAttr.includes(tagName))) {
+                    if (attrValue === null || attrValue === undefined) {
+                        delete newAttrs[attrName];
+                    } else if (typeof attrValue === 'string' && attrValue.trim() === '') {
+                        delete newAttrs[attrName];
                     }
                 }
             });

package/dist/_modules/removeEmptyElements.d.mts

@@ -0,0 +1,95 @@
+import PostHTML from 'posthtml';
+import { MinifyOptions } from 'terser';
+import { Options } from 'cssnano';
+import { Config } from 'svgo';
+import { UserDefinedOptions } from 'purgecss';
+
+type PostHTMLTreeLike = [PostHTML.Node] & PostHTML.NodeAPI & {
+    options?: {
+        quoteAllAttributes?: boolean | undefined;
+        quoteStyle?: 0 | 1 | 2 | undefined;
+        replaceQuote?: boolean | undefined;
+    } | undefined;
+    render(): string;
+    render(node: PostHTML.Node | PostHTMLTreeLike, renderOptions?: any): string;
+};
+type MaybeArray<T> = T | Array<T>;
+type PostHTMLNodeLike = PostHTML.Node | string;
+type HtmlnanoTemplateRule = {
+    tag: string;
+    attrs?: Record<string, string | boolean | void>;
+};
+type MinifyHtmlTemplateOptions = boolean | HtmlnanoTemplateRule[];
+interface HtmlnanoOptions {
+    skipConfigLoading?: boolean;
+    configPath?: string;
+    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;
+    minifyHtmlTemplate?: MinifyHtmlTemplateOptions;
+    minifyConditionalComments?: boolean;
+    minifyJs?: MinifyOptions | boolean;
+    minifyJson?: boolean;
+    minifyAttributes?: boolean | {
+        metaContent?: boolean;
+        redundantWhitespaces?: 'safe' | 'agressive' | false;
+    };
+    minifySvg?: Config | boolean;
+    normalizeAttributeValues?: boolean;
+    removeAttributeQuotes?: boolean | {
+        force?: boolean;
+    };
+    removeComments?: boolean | RegExp | ((comment: string) => boolean) | string;
+    removeEmptyAttributes?: boolean;
+    removeEmptyElements?: boolean | {
+        removeWithAttributes?: boolean;
+    };
+    removeRedundantAttributes?: boolean;
+    removeOptionalTags?: boolean;
+    removeUnusedCss?: boolean | ({
+        tool: 'purgeCSS';
+    } & Omit<UserDefinedOptions, 'content' | 'css' | 'extractors'>) | {
+        banner?: boolean;
+        csspath?: string;
+        htmlroot?: string;
+        ignore?: (string | RegExp)[];
+        inject?: string;
+        jsdom?: object;
+        media?: string[];
+        report?: boolean;
+        strictSSL?: boolean;
+        timeout?: number;
+        uncssrc?: string;
+        userAgent?: string;
+    };
+    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 RemoveEmptyElementsOptions {
+    removeWithAttributes?: boolean;
+}
+type RemoveEmptyElementsConfig = boolean | RemoveEmptyElementsOptions;
+declare const mod: HtmlnanoModule<RemoveEmptyElementsConfig>;
+
+export { mod as default };
+export type { RemoveEmptyElementsOptions };

package/dist/_modules/removeEmptyElements.d.ts

@@ -0,0 +1,95 @@
+import PostHTML from 'posthtml';
+import { MinifyOptions } from 'terser';
+import { Options } from 'cssnano';
+import { Config } from 'svgo';
+import { UserDefinedOptions } from 'purgecss';
+
+type PostHTMLTreeLike = [PostHTML.Node] & PostHTML.NodeAPI & {
+    options?: {
+        quoteAllAttributes?: boolean | undefined;
+        quoteStyle?: 0 | 1 | 2 | undefined;
+        replaceQuote?: boolean | undefined;
+    } | undefined;
+    render(): string;
+    render(node: PostHTML.Node | PostHTMLTreeLike, renderOptions?: any): string;
+};
+type MaybeArray<T> = T | Array<T>;
+type PostHTMLNodeLike = PostHTML.Node | string;
+type HtmlnanoTemplateRule = {
+    tag: string;
+    attrs?: Record<string, string | boolean | void>;
+};
+type MinifyHtmlTemplateOptions = boolean | HtmlnanoTemplateRule[];
+interface HtmlnanoOptions {
+    skipConfigLoading?: boolean;
+    configPath?: string;
+    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;
+    minifyHtmlTemplate?: MinifyHtmlTemplateOptions;
+    minifyConditionalComments?: boolean;
+    minifyJs?: MinifyOptions | boolean;
+    minifyJson?: boolean;
+    minifyAttributes?: boolean | {
+        metaContent?: boolean;
+        redundantWhitespaces?: 'safe' | 'agressive' | false;
+    };
+    minifySvg?: Config | boolean;
+    normalizeAttributeValues?: boolean;
+    removeAttributeQuotes?: boolean | {
+        force?: boolean;
+    };
+    removeComments?: boolean | RegExp | ((comment: string) => boolean) | string;
+    removeEmptyAttributes?: boolean;
+    removeEmptyElements?: boolean | {
+        removeWithAttributes?: boolean;
+    };
+    removeRedundantAttributes?: boolean;
+    removeOptionalTags?: boolean;
+    removeUnusedCss?: boolean | ({
+        tool: 'purgeCSS';
+    } & Omit<UserDefinedOptions, 'content' | 'css' | 'extractors'>) | {
+        banner?: boolean;
+        csspath?: string;
+        htmlroot?: string;
+        ignore?: (string | RegExp)[];
+        inject?: string;
+        jsdom?: object;
+        media?: string[];
+        report?: boolean;
+        strictSSL?: boolean;
+        timeout?: number;
+        uncssrc?: string;
+        userAgent?: string;
+    };
+    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 RemoveEmptyElementsOptions {
+    removeWithAttributes?: boolean;
+}
+type RemoveEmptyElementsConfig = boolean | RemoveEmptyElementsOptions;
+declare const mod: HtmlnanoModule<RemoveEmptyElementsConfig>;
+
+export { mod as default };
+export type { RemoveEmptyElementsOptions };

package/dist/_modules/removeEmptyElements.js

@@ -0,0 +1,90 @@
+Object.defineProperty(exports, '__esModule', { value: true });
+
+var helpers_js = require('../helpers.js');
+
+const voidElements = new Set([
+    'area',
+    'base',
+    'br',
+    'col',
+    'embed',
+    'hr',
+    'img',
+    'input',
+    'link',
+    'meta',
+    'param',
+    'source',
+    'track',
+    'wbr'
+]);
+function normalizeOptions(moduleOptions) {
+    if (typeof moduleOptions === 'object' && moduleOptions) {
+        return {
+            removeWithAttributes: moduleOptions.removeWithAttributes === true
+        };
+    }
+    return {
+        removeWithAttributes: false
+    };
+}
+function hasAttributes(node) {
+    return !!node.attrs && Object.keys(node.attrs).length > 0;
+}
+function isIgnorableText(text) {
+    return helpers_js.isComment(text) || text.trim() === '';
+}
+function isEmptyContent(content) {
+    if (!content) {
+        return true;
+    }
+    const contentArray = Array.isArray(content) ? content : [
+        content
+    ];
+    if (contentArray.length === 0) {
+        return true;
+    }
+    return contentArray.every((child)=>typeof child === 'string' && isIgnorableText(child));
+}
+function shouldRemoveNode(node, options) {
+    if (!node.tag || typeof node.tag !== 'string') {
+        return false;
+    }
+    if (voidElements.has(node.tag.toLowerCase())) {
+        return false;
+    }
+    if (!options.removeWithAttributes && hasAttributes(node)) {
+        return false;
+    }
+    return isEmptyContent(node.content);
+}
+function pruneNodes(nodes, options) {
+    const result = [];
+    for (const node of nodes){
+        if (typeof node === 'string') {
+            result.push(node);
+            continue;
+        }
+        if (node.content) {
+            const contentArray = Array.isArray(node.content) ? node.content : [
+                node.content
+            ];
+            node.content = pruneNodes(contentArray, options);
+        }
+        if (shouldRemoveNode(node, options)) {
+            continue;
+        }
+        result.push(node);
+    }
+    return result;
+}
+const mod = {
+    default (tree, _options, moduleOptions) {
+        const normalizedOptions = normalizeOptions(moduleOptions);
+        const pruned = pruneNodes(tree, normalizedOptions);
+        tree.splice(0, tree.length, ...pruned);
+        return tree;
+    }
+};
+
+exports.default = mod;

package/dist/_modules/removeEmptyElements.mjs

@@ -0,0 +1,88 @@
+import { isComment } from '../helpers.mjs';
+
+const voidElements = new Set([
+    'area',
+    'base',
+    'br',
+    'col',
+    'embed',
+    'hr',
+    'img',
+    'input',
+    'link',
+    'meta',
+    'param',
+    'source',
+    'track',
+    'wbr'
+]);
+function normalizeOptions(moduleOptions) {
+    if (typeof moduleOptions === 'object' && moduleOptions) {
+        return {
+            removeWithAttributes: moduleOptions.removeWithAttributes === true
+        };
+    }
+    return {
+        removeWithAttributes: false
+    };
+}
+function hasAttributes(node) {
+    return !!node.attrs && Object.keys(node.attrs).length > 0;
+}
+function isIgnorableText(text) {
+    return isComment(text) || text.trim() === '';
+}
+function isEmptyContent(content) {
+    if (!content) {
+        return true;
+    }
+    const contentArray = Array.isArray(content) ? content : [
+        content
+    ];
+    if (contentArray.length === 0) {
+        return true;
+    }
+    return contentArray.every((child)=>typeof child === 'string' && isIgnorableText(child));
+}
+function shouldRemoveNode(node, options) {
+    if (!node.tag || typeof node.tag !== 'string') {
+        return false;
+    }
+    if (voidElements.has(node.tag.toLowerCase())) {
+        return false;
+    }
+    if (!options.removeWithAttributes && hasAttributes(node)) {
+        return false;
+    }
+    return isEmptyContent(node.content);
+}
+function pruneNodes(nodes, options) {
+    const result = [];
+    for (const node of nodes){
+        if (typeof node === 'string') {
+            result.push(node);
+            continue;
+        }
+        if (node.content) {
+            const contentArray = Array.isArray(node.content) ? node.content : [
+                node.content
+            ];
+            node.content = pruneNodes(contentArray, options);
+        }
+        if (shouldRemoveNode(node, options)) {
+            continue;
+        }
+        result.push(node);
+    }
+    return result;
+}
+const mod = {
+    default (tree, _options, moduleOptions) {
+        const normalizedOptions = normalizeOptions(moduleOptions);
+        const pruned = pruneNodes(tree, normalizedOptions);
+        tree.splice(0, tree.length, ...pruned);
+        return tree;
+    }
+};
+
+export { mod as default };