htmlnano 3.0.0 → 3.1.0

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

@@ -2,6 +2,60 @@ Object.defineProperty(exports, '__esModule', { value: true });
 
 var helpers_js = require('../helpers.js');
 
+const booleanAttrs = new Set([
+    'amp-custom',
+    'disabled'
+]);
+function normalizeStyleType(attrs) {
+    if (!attrs || typeof attrs.type !== 'string') {
+        return 'text/css';
+    }
+    const type = attrs.type.trim();
+    return type ? type.toLowerCase() : 'text/css';
+}
+function normalizeStyleMedia(attrs) {
+    if (!attrs || typeof attrs.media !== 'string') {
+        return 'all';
+    }
+    const media = attrs.media.trim();
+    return media ? media.replace(/\s+/g, ' ').toLowerCase() : 'all';
+}
+function normalizeStyleAttrsForKey(attrs) {
+    const normalized = {};
+    for (const [key, value] of Object.entries(attrs || {})){
+        if (key === 'type' || key === 'media') {
+            continue;
+        }
+        if (value === undefined) {
+            continue;
+        }
+        if (booleanAttrs.has(key)) {
+            normalized[key] = true;
+            continue;
+        }
+        normalized[key] = value;
+    }
+    return normalized;
+}
+function buildStyleKey(attrs) {
+    const keyObject = {
+        type: normalizeStyleType(attrs),
+        media: normalizeStyleMedia(attrs),
+        ...normalizeStyleAttrsForKey(attrs)
+    };
+    const sortedKeys = Object.keys(keyObject).sort();
+    const sortedKeyObject = {};
+    for (const key of sortedKeys){
+        sortedKeyObject[key] = keyObject[key];
+    }
+    return JSON.stringify(sortedKeyObject);
+}
+function extractStyleTextContent(node) {
+    if (typeof node.content === 'string') {
+        return node.content;
+    }
+    return helpers_js.extractTextContentFromNode(node);
+}
 /* Merge multiple <style> into one */ const mod = {
     default (tree) {
         const styleNodes = {};
@@ -20,12 +74,10 @@ var helpers_js = require('../helpers.js');
             if (helpers_js.isAmpBoilerplate(node)) {
                 return node;
             }
-            const styleType = nodeAttrs.type || 'text/css';
-            const styleMedia = nodeAttrs.media || 'all';
-            const styleKey = styleType + '_' + styleMedia;
+            const styleKey = buildStyleKey(nodeAttrs);
             if (styleKey in styleNodes) {
                 var _styleNodes_styleKey, _content;
-                const styleContent = helpers_js.extractTextContentFromNode(node);
+                const styleContent = extractStyleTextContent(node);
                 (_content = (_styleNodes_styleKey = styleNodes[styleKey]).content) != null ? _content : _styleNodes_styleKey.content = [];
                 styleNodes[styleKey].content.push(' ' + styleContent);
                 return ''; // Remove node

package/dist/_modules/mergeStyles.mjs

@@ -1,5 +1,59 @@
 import { isAmpBoilerplate, extractTextContentFromNode } from '../helpers.mjs';
 
+const booleanAttrs = new Set([
+    'amp-custom',
+    'disabled'
+]);
+function normalizeStyleType(attrs) {
+    if (!attrs || typeof attrs.type !== 'string') {
+        return 'text/css';
+    }
+    const type = attrs.type.trim();
+    return type ? type.toLowerCase() : 'text/css';
+}
+function normalizeStyleMedia(attrs) {
+    if (!attrs || typeof attrs.media !== 'string') {
+        return 'all';
+    }
+    const media = attrs.media.trim();
+    return media ? media.replace(/\s+/g, ' ').toLowerCase() : 'all';
+}
+function normalizeStyleAttrsForKey(attrs) {
+    const normalized = {};
+    for (const [key, value] of Object.entries(attrs || {})){
+        if (key === 'type' || key === 'media') {
+            continue;
+        }
+        if (value === undefined) {
+            continue;
+        }
+        if (booleanAttrs.has(key)) {
+            normalized[key] = true;
+            continue;
+        }
+        normalized[key] = value;
+    }
+    return normalized;
+}
+function buildStyleKey(attrs) {
+    const keyObject = {
+        type: normalizeStyleType(attrs),
+        media: normalizeStyleMedia(attrs),
+        ...normalizeStyleAttrsForKey(attrs)
+    };
+    const sortedKeys = Object.keys(keyObject).sort();
+    const sortedKeyObject = {};
+    for (const key of sortedKeys){
+        sortedKeyObject[key] = keyObject[key];
+    }
+    return JSON.stringify(sortedKeyObject);
+}
+function extractStyleTextContent(node) {
+    if (typeof node.content === 'string') {
+        return node.content;
+    }
+    return extractTextContentFromNode(node);
+}
 /* Merge multiple <style> into one */ const mod = {
     default (tree) {
         const styleNodes = {};
@@ -18,12 +72,10 @@ import { isAmpBoilerplate, extractTextContentFromNode } from '../helpers.mjs';
             if (isAmpBoilerplate(node)) {
                 return node;
             }
-            const styleType = nodeAttrs.type || 'text/css';
-            const styleMedia = nodeAttrs.media || 'all';
-            const styleKey = styleType + '_' + styleMedia;
+            const styleKey = buildStyleKey(nodeAttrs);
             if (styleKey in styleNodes) {
                 var _styleNodes_styleKey, _content;
-                const styleContent = extractTextContentFromNode(node);
+                const styleContent = extractStyleTextContent(node);
                 (_content = (_styleNodes_styleKey = styleNodes[styleKey]).content) != null ? _content : _styleNodes_styleKey.content = [];
                 styleNodes[styleKey].content.push(' ' + styleContent);
                 return ''; // Remove node

package/dist/_modules/minifyAttributes.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>;
+};
+
+type RedundantWhitespaceMode = 'safe' | 'agressive' | false;
+type MinifyAttributesOptions = {
+    metaContent?: boolean;
+    redundantWhitespaces?: RedundantWhitespaceMode | 'aggressive';
+};
+declare const mod: HtmlnanoModule<MinifyAttributesOptions>;
+
+export { mod as default };

package/dist/_modules/minifyAttributes.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>;
+};
+
+type RedundantWhitespaceMode = 'safe' | 'agressive' | false;
+type MinifyAttributesOptions = {
+    metaContent?: boolean;
+    redundantWhitespaces?: RedundantWhitespaceMode | 'aggressive';
+};
+declare const mod: HtmlnanoModule<MinifyAttributesOptions>;
+
+export { mod as default };

package/dist/_modules/minifyAttributes.js

@@ -0,0 +1,159 @@
+Object.defineProperty(exports, '__esModule', { value: true });
+
+var helpers_js = require('../helpers.js');
+var collapseAttributeWhitespace_js = require('./collapseAttributeWhitespace.js');
+
+const asciiWhitespace = new Set([
+    '\t',
+    '\n',
+    '\f',
+    '\r',
+    ' '
+]);
+const defaultOptions = {
+    metaContent: true,
+    redundantWhitespaces: 'safe'
+};
+function isAsciiWhitespace(char) {
+    return asciiWhitespace.has(char);
+}
+function isAsciiDigit(char) {
+    return char >= '0' && char <= '9';
+}
+function skipAsciiWhitespace(input, start) {
+    let pos = start;
+    while(pos < input.length && isAsciiWhitespace(input[pos])){
+        pos += 1;
+    }
+    return pos;
+}
+function minifyMetaRefreshValue(value) {
+    const input = value;
+    let pos = skipAsciiWhitespace(input, 0);
+    const timeStart = pos;
+    while(pos < input.length && isAsciiDigit(input[pos])){
+        pos += 1;
+    }
+    if (pos === timeStart) return null;
+    const time = input.slice(timeStart, pos);
+    while(pos < input.length){
+        const ch = input[pos];
+        if (isAsciiDigit(ch) || ch === '.') {
+            pos += 1;
+            continue;
+        }
+        break;
+    }
+    pos = skipAsciiWhitespace(input, pos);
+    if (pos >= input.length) return time;
+    const separator = input[pos];
+    if (separator !== ';' && separator !== ',') return null;
+    pos += 1;
+    pos = skipAsciiWhitespace(input, pos);
+    if (pos >= input.length) return time;
+    let hasUrlPrefix = false;
+    if (input[pos] === 'u' || input[pos] === 'U') {
+        if (pos + 2 < input.length) {
+            const maybeUrl = input.slice(pos, pos + 3);
+            if (maybeUrl.toLowerCase() === 'url') {
+                let prefixPos = skipAsciiWhitespace(input, pos + 3);
+                if (prefixPos < input.length && input[prefixPos] === '=') {
+                    prefixPos = skipAsciiWhitespace(input, prefixPos + 1);
+                    hasUrlPrefix = true;
+                    pos = prefixPos;
+                }
+            }
+        }
+    }
+    if (pos >= input.length) return time;
+    const firstUrlChar = input[pos];
+    if (firstUrlChar === '"' || firstUrlChar === '\'') {
+        if (!hasUrlPrefix) return null;
+        const quote = firstUrlChar;
+        const urlStart = pos + 1;
+        const quoteIndex = input.indexOf(quote, urlStart);
+        const url = quoteIndex === -1 ? input.slice(urlStart) : input.slice(urlStart, quoteIndex);
+        if (!url) return time;
+        const closingQuote = quoteIndex === -1 ? '' : quote;
+        return `${time}${separator} URL=${quote}${url}${closingQuote}`;
+    }
+    const url = input.slice(pos).trim();
+    if (!url) return time;
+    return `${time}${separator} ${url}`;
+}
+function isMetaRefresh(attrs, tagName) {
+    if (!tagName || tagName.toLowerCase() !== 'meta') return false;
+    const httpEquiv = attrs['http-equiv'];
+    if (typeof httpEquiv !== 'string') return false;
+    return httpEquiv.trim().toLowerCase() === 'refresh';
+}
+function normalizeOptions(moduleOptions) {
+    if (moduleOptions && typeof moduleOptions === 'object') {
+        let redundantWhitespaces = defaultOptions.redundantWhitespaces;
+        if (moduleOptions.redundantWhitespaces === 'aggressive') {
+            redundantWhitespaces = 'agressive';
+        } else if (moduleOptions.redundantWhitespaces === 'safe' || moduleOptions.redundantWhitespaces === 'agressive' || moduleOptions.redundantWhitespaces === false) {
+            redundantWhitespaces = moduleOptions.redundantWhitespaces;
+        }
+        return {
+            metaContent: moduleOptions.metaContent !== false,
+            redundantWhitespaces
+        };
+    }
+    return defaultOptions;
+}
+function collapseWhitespace(value) {
+    return value.replace(/\s+/g, ' ').trim();
+}
+function minifyAttributeWhitespace(mode, attrName, attrValue, tagName) {
+    if (!mode) {
+        return null;
+    }
+    const attrNameLower = attrName.toLowerCase();
+    if (collapseAttributeWhitespace_js.isListAttribute(attrNameLower, tagName)) {
+        const collapsed = collapseWhitespace(attrValue);
+        return collapsed === attrValue ? null : collapsed;
+    }
+    if (helpers_js.isEventHandler(attrName)) {
+        const trimmed = attrValue.trim();
+        return trimmed === attrValue ? null : trimmed;
+    }
+    if (collapseAttributeWhitespace_js.isSingleValueAttribute(attrNameLower, tagName)) {
+        const trimmed = attrValue.trim();
+        return trimmed === attrValue ? null : trimmed;
+    }
+    if (mode === 'agressive') {
+        const trimmed = attrValue.trim();
+        return trimmed === attrValue ? null : trimmed;
+    }
+    return null;
+}
+const mod = {
+    onAttrs (_options, moduleOptions) {
+        const normalizedOptions = normalizeOptions(moduleOptions);
+        return (attrs, node)=>{
+            if (normalizedOptions.metaContent && isMetaRefresh(attrs, node.tag)) {
+                const content = attrs.content;
+                if (typeof content === 'string') {
+                    const minified = minifyMetaRefreshValue(content);
+                    if (minified !== null && minified !== content) {
+                        attrs.content = minified;
+                    }
+                }
+            }
+            if (normalizedOptions.redundantWhitespaces) {
+                const tagName = node.tag ? node.tag.toLowerCase() : undefined;
+                Object.entries(attrs).forEach(([attrName, attrValue])=>{
+                    if (typeof attrValue !== 'string') return;
+                    const minified = minifyAttributeWhitespace(normalizedOptions.redundantWhitespaces, attrName, attrValue, tagName);
+                    if (minified !== null) {
+                        attrs[attrName] = minified;
+                    }
+                });
+            }
+            return attrs;
+        };
+    }
+};
+
+exports.default = mod;