htmlnano 2.1.1 → 2.1.3

package/dist/helpers.js

@@ -0,0 +1,72 @@
+Object.defineProperty(exports, '__esModule', { value: true });
+
+const ampBoilerplateAttributes = [
+    'amp-boilerplate',
+    'amp4ads-boilerplate',
+    'amp4email-boilerplate'
+];
+function isAmpBoilerplate(node) {
+    if (!node.attrs) {
+        return false;
+    }
+    for (const attr of ampBoilerplateAttributes){
+        if (attr in node.attrs) {
+            return true;
+        }
+    }
+    return false;
+}
+function isComment(content) {
+    if (typeof content === 'string') {
+        return content.trim().startsWith('<!--');
+    }
+    return false;
+}
+function isConditionalComment(content) {
+    const clean = (content || '').trim();
+    return clean.startsWith('<!--[if') || clean === '<!--<![endif]-->';
+}
+function isStyleNode(node) {
+    return node.tag === 'style' && !isAmpBoilerplate(node) && 'content' in node && node.content && node.content.length > 0;
+}
+function extractCssFromStyleNode(node) {
+    return Array.isArray(node.content) ? node.content.join(' ') : node.content;
+}
+function isEventHandler(attributeName) {
+    return attributeName && attributeName.slice(0, 2).toLowerCase() === 'on' && attributeName.length >= 5;
+}
+function extractTextContentFromNode(node) {
+    if (!node.content) {
+        return '';
+    }
+    if (!Array.isArray(node.content)) {
+        return '';
+    }
+    let content = '';
+    for (const child of node.content){
+        if (typeof child === 'string') {
+            content += child;
+        }
+    }
+    return content;
+}
+async function optionalImport(moduleName) {
+    try {
+        const module = await import(moduleName);
+        return module.default || module;
+    } catch (e) {
+        if (typeof e === 'object' && e && 'code' in e && (e.code === 'MODULE_NOT_FOUND' || e.code === 'ERR_MODULE_NOT_FOUND')) {
+            return null;
+        }
+        throw e;
+    }
+}
+
+exports.extractCssFromStyleNode = extractCssFromStyleNode;
+exports.extractTextContentFromNode = extractTextContentFromNode;
+exports.isAmpBoilerplate = isAmpBoilerplate;
+exports.isComment = isComment;
+exports.isConditionalComment = isConditionalComment;
+exports.isEventHandler = isEventHandler;
+exports.isStyleNode = isStyleNode;
+exports.optionalImport = optionalImport;

package/dist/helpers.mjs

@@ -0,0 +1,63 @@
+const ampBoilerplateAttributes = [
+    'amp-boilerplate',
+    'amp4ads-boilerplate',
+    'amp4email-boilerplate'
+];
+function isAmpBoilerplate(node) {
+    if (!node.attrs) {
+        return false;
+    }
+    for (const attr of ampBoilerplateAttributes){
+        if (attr in node.attrs) {
+            return true;
+        }
+    }
+    return false;
+}
+function isComment(content) {
+    if (typeof content === 'string') {
+        return content.trim().startsWith('<!--');
+    }
+    return false;
+}
+function isConditionalComment(content) {
+    const clean = (content || '').trim();
+    return clean.startsWith('<!--[if') || clean === '<!--<![endif]-->';
+}
+function isStyleNode(node) {
+    return node.tag === 'style' && !isAmpBoilerplate(node) && 'content' in node && node.content && node.content.length > 0;
+}
+function extractCssFromStyleNode(node) {
+    return Array.isArray(node.content) ? node.content.join(' ') : node.content;
+}
+function isEventHandler(attributeName) {
+    return attributeName && attributeName.slice(0, 2).toLowerCase() === 'on' && attributeName.length >= 5;
+}
+function extractTextContentFromNode(node) {
+    if (!node.content) {
+        return '';
+    }
+    if (!Array.isArray(node.content)) {
+        return '';
+    }
+    let content = '';
+    for (const child of node.content){
+        if (typeof child === 'string') {
+            content += child;
+        }
+    }
+    return content;
+}
+async function optionalImport(moduleName) {
+    try {
+        const module = await import(moduleName);
+        return module.default || module;
+    } catch (e) {
+        if (typeof e === 'object' && e && 'code' in e && (e.code === 'MODULE_NOT_FOUND' || e.code === 'ERR_MODULE_NOT_FOUND')) {
+            return null;
+        }
+        throw e;
+    }
+}
+
+export { extractCssFromStyleNode, extractTextContentFromNode, isAmpBoilerplate, isComment, isConditionalComment, isEventHandler, isStyleNode, optionalImport };

package/dist/index.js

@@ -0,0 +1,223 @@
+Object.defineProperty(exports, '__esModule', { value: true });
+
+var posthtml = require('posthtml');
+var cosmiconfig = require('cosmiconfig');
+var safePreset = require('./presets/safe.js');
+var ampSafePreset = require('./presets/ampSafe.js');
+var maxPreset = require('./presets/max.js');
+
+function _interopDefault (e) { return e && e.__esModule ? e : { default: e }; }
+
+var posthtml__default = /*#__PURE__*/_interopDefault(posthtml);
+var safePreset__default = /*#__PURE__*/_interopDefault(safePreset);
+var ampSafePreset__default = /*#__PURE__*/_interopDefault(ampSafePreset);
+var maxPreset__default = /*#__PURE__*/_interopDefault(maxPreset);
+
+const presets = {
+    safe: safePreset__default.default,
+    ampSafe: ampSafePreset__default.default,
+    max: maxPreset__default.default
+};
+function loadConfig(options, preset, configPath) {
+    const { skipConfigLoading = false, ...rest } = options || {};
+    let restConfig = rest;
+    if (!skipConfigLoading) {
+        const explorer = cosmiconfig.cosmiconfigSync('htmlnano');
+        const rc = configPath ? explorer.load(configPath) : explorer.search();
+        if (rc) {
+            const { preset: presetName } = rc.config;
+            if (presetName) {
+                if (!preset && presetName in presets) {
+                    preset = presets[presetName];
+                }
+                delete rc.config.preset;
+            }
+            if (!options) {
+                restConfig = rc.config;
+            }
+        }
+    }
+    return [
+        restConfig || {},
+        preset || safePreset__default.default
+    ];
+}
+const optionalDependencies = {
+    minifyCss: [
+        'cssnano',
+        'postcss'
+    ],
+    minifyJs: [
+        'terser'
+    ],
+    minifyUrls: [
+        'relateurl',
+        'srcset',
+        'terser'
+    ],
+    minifySvg: [
+        'svgo'
+    ]
+};
+const interop = (imported)=>imported.then((mod)=>mod.default);
+const modules = {
+    collapseAttributeWhitespace: ()=>interop(import('./_modules/collapseAttributeWhitespace.js')),
+    collapseBooleanAttributes: ()=>interop(import('./_modules/collapseBooleanAttributes.js')),
+    collapseWhitespace: ()=>interop(import('./_modules/collapseWhitespace.js')),
+    custom: ()=>interop(import('./_modules/custom.js')),
+    deduplicateAttributeValues: ()=>interop(import('./_modules/deduplicateAttributeValues.js')),
+    // example: () => import('./_modules/example.mjs'),
+    mergeScripts: ()=>interop(import('./_modules/mergeScripts.js')),
+    mergeStyles: ()=>interop(import('./_modules/mergeStyles.js')),
+    minifyConditionalComments: ()=>interop(import('./_modules/minifyConditionalComments.js')),
+    minifyCss: ()=>interop(import('./_modules/minifyCss.js')),
+    minifyJs: ()=>interop(import('./_modules/minifyJs.js')),
+    minifyJson: ()=>interop(import('./_modules/minifyJson.js')),
+    minifySvg: ()=>interop(import('./_modules/minifySvg.js')),
+    minifyUrls: ()=>interop(import('./_modules/minifyUrls.js')),
+    normalizeAttributeValues: ()=>interop(import('./_modules/normalizeAttributeValues.js')),
+    removeAttributeQuotes: ()=>interop(import('./_modules/removeAttributeQuotes.js')),
+    removeComments: ()=>interop(import('./_modules/removeComments.js')),
+    removeEmptyAttributes: ()=>interop(import('./_modules/removeEmptyAttributes.js')),
+    removeOptionalTags: ()=>interop(import('./_modules/removeOptionalTags.js')),
+    removeRedundantAttributes: ()=>interop(import('./_modules/removeRedundantAttributes.js')),
+    removeUnusedCss: ()=>interop(import('./_modules/removeUnusedCss.js')),
+    sortAttributes: ()=>interop(import('./_modules/sortAttributes.js')),
+    sortAttributesWithLists: ()=>interop(import('./_modules/sortAttributesWithLists.js'))
+};
+function htmlnano(optionsRun = {}, presetRun) {
+    // eslint-disable-next-line prefer-const -- re-assign options
+    let [options, preset] = loadConfig(optionsRun, presetRun);
+    const minifier = async (_tree)=>{
+        const tree = _tree;
+        const nodeHandlers = [];
+        const attrsHandlers = [];
+        const contentsHandlers = [];
+        options = {
+            ...preset,
+            ...options
+        };
+        let promise = Promise.resolve(tree);
+        for (const [moduleName, moduleOptions] of Object.entries(options)){
+            if (!moduleOptions) {
+                continue;
+            }
+            if (!(moduleName in safePreset__default.default)) {
+                throw new Error('Module "' + moduleName + '" is not defined');
+            }
+            if (moduleName in optionalDependencies) {
+                const modules = optionalDependencies[moduleName];
+                await Promise.all(modules.map(async (dependency)=>{
+                    try {
+                        await import(dependency);
+                    } catch (e) {
+                        if (typeof e === 'object' && e !== null && 'code' in e && typeof e.code === 'string') {
+                            if (e.code === 'MODULE_NOT_FOUND' || e.code === 'ERR_MODULE_NOT_FOUND') {
+                                if (!options.skipInternalWarnings) {
+                                    console.warn(`You have to install "${dependency}" in order to use htmlnano's "${moduleName}" module`);
+                                    return;
+                                }
+                            }
+                            throw e;
+                        }
+                    }
+                }));
+            }
+            const mod = moduleName in modules ? await modules[moduleName]() : await import(`./_modules/${moduleName}.mjs`);
+            if (typeof mod.onAttrs === 'function') {
+                attrsHandlers.push(mod.onAttrs(options, moduleOptions));
+            }
+            if (typeof mod.onContent === 'function') {
+                contentsHandlers.push(mod.onContent(options, moduleOptions));
+            }
+            if (typeof mod.onNode === 'function') {
+                nodeHandlers.push(mod.onNode(options, moduleOptions));
+            }
+            if (typeof mod.default === 'function') {
+                promise = promise.then(async (tree)=>await mod.default(tree, options, moduleOptions));
+            }
+        }
+        if (attrsHandlers.length + contentsHandlers.length + nodeHandlers.length === 0) {
+            return promise;
+        }
+        return promise.then((tree)=>{
+            tree.walk((node)=>{
+                if (node) {
+                    if (node.attrs && typeof node.attrs === 'object') {
+                        // Convert all attrs' key to lower case
+                        let newAttrsObj = {};
+                        Object.entries(node.attrs).forEach(([attrName, attrValue])=>{
+                            newAttrsObj[attrName.toLowerCase()] = attrValue;
+                        });
+                        for (const handler of attrsHandlers){
+                            newAttrsObj = handler(newAttrsObj, node);
+                        }
+                        node.attrs = newAttrsObj;
+                    }
+                    if (node.content) {
+                        node.content = typeof node.content === 'string' ? [
+                            node.content
+                        ] : node.content;
+                        if (Array.isArray(node.content) && node.content.length > 0) {
+                            for (const handler of contentsHandlers){
+                                var _node_content;
+                                const result = handler((_node_content = node.content) != null ? _node_content : [], node);
+                                node.content = Array.isArray(result) ? result : [
+                                    result
+                                ];
+                            }
+                        }
+                    }
+                    for (const handler of nodeHandlers){
+                        if (handler) {
+                            node = handler(node);
+                        }
+                    }
+                }
+                return node;
+            });
+            return tree;
+        });
+    };
+    return minifier;
+}
+function getRequiredOptionalDependencies(optionsRun, presetRun) {
+    const [options] = loadConfig(optionsRun, presetRun);
+    return Array.from(Object.keys(options).reduce((acc, moduleName)=>{
+        if (moduleName in optionalDependencies) {
+            const dependencies = optionalDependencies[moduleName];
+            // eslint-disable-next-line @typescript-eslint/unbound-method -- thisArg provided by forEach
+            dependencies.forEach(acc.add, acc);
+        }
+        return acc;
+    }, new Set()));
+}
+function process(html, options, preset, postHtmlOptions) {
+    return posthtml__default.default([
+        htmlnano(options, preset)
+    ]).process(html, postHtmlOptions);
+}
+// https://github.com/webpack-contrib/html-minimizer-webpack-plugin/blob/faca00f2219514bc671c5942685721f0b5dbaa70/src/utils.js#L74
+function htmlMinimizerWebpackPluginMinify(input, minimizerOptions) {
+    const [[, code]] = Object.entries(input);
+    return htmlnano.process(code, minimizerOptions, presets.safe).then((result)=>{
+        return {
+            code: result.html
+        };
+    });
+}
+htmlnano.presets = presets;
+htmlnano.getRequiredOptionalDependencies = getRequiredOptionalDependencies;
+htmlnano.process = process;
+htmlnano.htmlMinimizerWebpackPluginMinify = htmlMinimizerWebpackPluginMinify;
+htmlnano.loadConfig = loadConfig;
+if (typeof module !== 'undefined') {
+    module.exports = htmlnano;
+}
+
+exports.default = htmlnano;
+exports.getRequiredOptionalDependencies = getRequiredOptionalDependencies;
+exports.htmlMinimizerWebpackPluginMinify = htmlMinimizerWebpackPluginMinify;
+exports.htmlnano = htmlnano;
+exports.loadConfig = loadConfig;
+exports.process = process;

package/dist/index.mjs

@@ -0,0 +1,209 @@
+import posthtml from 'posthtml';
+import { cosmiconfigSync } from 'cosmiconfig';
+import safePreset from './presets/safe.mjs';
+import ampSafePreset from './presets/ampSafe.mjs';
+import maxPreset from './presets/max.mjs';
+
+const presets = {
+    safe: safePreset,
+    ampSafe: ampSafePreset,
+    max: maxPreset
+};
+function loadConfig(options, preset, configPath) {
+    const { skipConfigLoading = false, ...rest } = options || {};
+    let restConfig = rest;
+    if (!skipConfigLoading) {
+        const explorer = cosmiconfigSync('htmlnano');
+        const rc = configPath ? explorer.load(configPath) : explorer.search();
+        if (rc) {
+            const { preset: presetName } = rc.config;
+            if (presetName) {
+                if (!preset && presetName in presets) {
+                    preset = presets[presetName];
+                }
+                delete rc.config.preset;
+            }
+            if (!options) {
+                restConfig = rc.config;
+            }
+        }
+    }
+    return [
+        restConfig || {},
+        preset || safePreset
+    ];
+}
+const optionalDependencies = {
+    minifyCss: [
+        'cssnano',
+        'postcss'
+    ],
+    minifyJs: [
+        'terser'
+    ],
+    minifyUrls: [
+        'relateurl',
+        'srcset',
+        'terser'
+    ],
+    minifySvg: [
+        'svgo'
+    ]
+};
+const interop = (imported)=>imported.then((mod)=>mod.default);
+const modules = {
+    collapseAttributeWhitespace: ()=>interop(import('./_modules/collapseAttributeWhitespace.mjs')),
+    collapseBooleanAttributes: ()=>interop(import('./_modules/collapseBooleanAttributes.mjs')),
+    collapseWhitespace: ()=>interop(import('./_modules/collapseWhitespace.mjs')),
+    custom: ()=>interop(import('./_modules/custom.mjs')),
+    deduplicateAttributeValues: ()=>interop(import('./_modules/deduplicateAttributeValues.mjs')),
+    // example: () => import('./_modules/example.mjs'),
+    mergeScripts: ()=>interop(import('./_modules/mergeScripts.mjs')),
+    mergeStyles: ()=>interop(import('./_modules/mergeStyles.mjs')),
+    minifyConditionalComments: ()=>interop(import('./_modules/minifyConditionalComments.mjs')),
+    minifyCss: ()=>interop(import('./_modules/minifyCss.mjs')),
+    minifyJs: ()=>interop(import('./_modules/minifyJs.mjs')),
+    minifyJson: ()=>interop(import('./_modules/minifyJson.mjs')),
+    minifySvg: ()=>interop(import('./_modules/minifySvg.mjs')),
+    minifyUrls: ()=>interop(import('./_modules/minifyUrls.mjs')),
+    normalizeAttributeValues: ()=>interop(import('./_modules/normalizeAttributeValues.mjs')),
+    removeAttributeQuotes: ()=>interop(import('./_modules/removeAttributeQuotes.mjs')),
+    removeComments: ()=>interop(import('./_modules/removeComments.mjs')),
+    removeEmptyAttributes: ()=>interop(import('./_modules/removeEmptyAttributes.mjs')),
+    removeOptionalTags: ()=>interop(import('./_modules/removeOptionalTags.mjs')),
+    removeRedundantAttributes: ()=>interop(import('./_modules/removeRedundantAttributes.mjs')),
+    removeUnusedCss: ()=>interop(import('./_modules/removeUnusedCss.mjs')),
+    sortAttributes: ()=>interop(import('./_modules/sortAttributes.mjs')),
+    sortAttributesWithLists: ()=>interop(import('./_modules/sortAttributesWithLists.mjs'))
+};
+function htmlnano(optionsRun = {}, presetRun) {
+    // eslint-disable-next-line prefer-const -- re-assign options
+    let [options, preset] = loadConfig(optionsRun, presetRun);
+    const minifier = async (_tree)=>{
+        const tree = _tree;
+        const nodeHandlers = [];
+        const attrsHandlers = [];
+        const contentsHandlers = [];
+        options = {
+            ...preset,
+            ...options
+        };
+        let promise = Promise.resolve(tree);
+        for (const [moduleName, moduleOptions] of Object.entries(options)){
+            if (!moduleOptions) {
+                continue;
+            }
+            if (!(moduleName in safePreset)) {
+                throw new Error('Module "' + moduleName + '" is not defined');
+            }
+            if (moduleName in optionalDependencies) {
+                const modules = optionalDependencies[moduleName];
+                await Promise.all(modules.map(async (dependency)=>{
+                    try {
+                        await import(dependency);
+                    } catch (e) {
+                        if (typeof e === 'object' && e !== null && 'code' in e && typeof e.code === 'string') {
+                            if (e.code === 'MODULE_NOT_FOUND' || e.code === 'ERR_MODULE_NOT_FOUND') {
+                                if (!options.skipInternalWarnings) {
+                                    console.warn(`You have to install "${dependency}" in order to use htmlnano's "${moduleName}" module`);
+                                    return;
+                                }
+                            }
+                            throw e;
+                        }
+                    }
+                }));
+            }
+            const mod = moduleName in modules ? await modules[moduleName]() : await import(`./_modules/${moduleName}.mjs`);
+            if (typeof mod.onAttrs === 'function') {
+                attrsHandlers.push(mod.onAttrs(options, moduleOptions));
+            }
+            if (typeof mod.onContent === 'function') {
+                contentsHandlers.push(mod.onContent(options, moduleOptions));
+            }
+            if (typeof mod.onNode === 'function') {
+                nodeHandlers.push(mod.onNode(options, moduleOptions));
+            }
+            if (typeof mod.default === 'function') {
+                promise = promise.then(async (tree)=>await mod.default(tree, options, moduleOptions));
+            }
+        }
+        if (attrsHandlers.length + contentsHandlers.length + nodeHandlers.length === 0) {
+            return promise;
+        }
+        return promise.then((tree)=>{
+            tree.walk((node)=>{
+                if (node) {
+                    if (node.attrs && typeof node.attrs === 'object') {
+                        // Convert all attrs' key to lower case
+                        let newAttrsObj = {};
+                        Object.entries(node.attrs).forEach(([attrName, attrValue])=>{
+                            newAttrsObj[attrName.toLowerCase()] = attrValue;
+                        });
+                        for (const handler of attrsHandlers){
+                            newAttrsObj = handler(newAttrsObj, node);
+                        }
+                        node.attrs = newAttrsObj;
+                    }
+                    if (node.content) {
+                        node.content = typeof node.content === 'string' ? [
+                            node.content
+                        ] : node.content;
+                        if (Array.isArray(node.content) && node.content.length > 0) {
+                            for (const handler of contentsHandlers){
+                                var _node_content;
+                                const result = handler((_node_content = node.content) != null ? _node_content : [], node);
+                                node.content = Array.isArray(result) ? result : [
+                                    result
+                                ];
+                            }
+                        }
+                    }
+                    for (const handler of nodeHandlers){
+                        if (handler) {
+                            node = handler(node);
+                        }
+                    }
+                }
+                return node;
+            });
+            return tree;
+        });
+    };
+    return minifier;
+}
+function getRequiredOptionalDependencies(optionsRun, presetRun) {
+    const [options] = loadConfig(optionsRun, presetRun);
+    return Array.from(Object.keys(options).reduce((acc, moduleName)=>{
+        if (moduleName in optionalDependencies) {
+            const dependencies = optionalDependencies[moduleName];
+            // eslint-disable-next-line @typescript-eslint/unbound-method -- thisArg provided by forEach
+            dependencies.forEach(acc.add, acc);
+        }
+        return acc;
+    }, new Set()));
+}
+function process(html, options, preset, postHtmlOptions) {
+    return posthtml([
+        htmlnano(options, preset)
+    ]).process(html, postHtmlOptions);
+}
+// https://github.com/webpack-contrib/html-minimizer-webpack-plugin/blob/faca00f2219514bc671c5942685721f0b5dbaa70/src/utils.js#L74
+function htmlMinimizerWebpackPluginMinify(input, minimizerOptions) {
+    const [[, code]] = Object.entries(input);
+    return htmlnano.process(code, minimizerOptions, presets.safe).then((result)=>{
+        return {
+            code: result.html
+        };
+    });
+}
+htmlnano.presets = presets;
+htmlnano.getRequiredOptionalDependencies = getRequiredOptionalDependencies;
+htmlnano.process = process;
+htmlnano.htmlMinimizerWebpackPluginMinify = htmlMinimizerWebpackPluginMinify;
+htmlnano.loadConfig = loadConfig;
+if (typeof module !== 'undefined') {
+    module.exports = htmlnano;
+}
+
+export { htmlnano as default, getRequiredOptionalDependencies, htmlMinimizerWebpackPluginMinify, htmlnano, loadConfig, process };

package/dist/presets/ampSafe.js

@@ -0,0 +1,19 @@
+Object.defineProperty(exports, '__esModule', { value: true });
+
+var safePreset = require('./safe.js');
+
+function _interopDefault (e) { return e && e.__esModule ? e : { default: e }; }
+
+var safePreset__default = /*#__PURE__*/_interopDefault(safePreset);
+
+/**
+ * A safe preset for AMP pages (https://www.ampproject.org)
+ */ var ampSafe = {
+    ...safePreset__default.default,
+    collapseBooleanAttributes: {
+        amphtml: true
+    },
+    minifyJs: false
+};
+
+exports.default = ampSafe;

package/{lib → dist}/presets/ampSafe.mjs

@@ -2,10 +2,12 @@ import safePreset from './safe.mjs';
 
 /**
  * A safe preset for AMP pages (https://www.ampproject.org)
- */
-export default { ...safePreset,
+ */ var ampSafe = {
+    ...safePreset,
     collapseBooleanAttributes: {
-        amphtml: true,
+        amphtml: true
     },
-    minifyJs: false,
+    minifyJs: false
 };
+
+export { ampSafe as default };

package/dist/presets/max.js

@@ -0,0 +1,28 @@
+Object.defineProperty(exports, '__esModule', { value: true });
+
+var safePreset = require('./safe.js');
+
+function _interopDefault (e) { return e && e.__esModule ? e : { default: e }; }
+
+var safePreset__default = /*#__PURE__*/_interopDefault(safePreset);
+
+/**
+ * Maximal minification (might break some pages)
+ */ var max = {
+    ...safePreset__default.default,
+    collapseWhitespace: 'all',
+    removeComments: 'all',
+    removeAttributeQuotes: true,
+    removeRedundantAttributes: true,
+    mergeScripts: true,
+    mergeStyles: true,
+    removeUnusedCss: {},
+    minifyCss: {
+        preset: 'default'
+    },
+    minifySvg: {},
+    minifyConditionalComments: true,
+    removeOptionalTags: true
+};
+
+exports.default = max;

package/{lib → dist}/presets/max.mjs

@@ -2,8 +2,8 @@ import safePreset from './safe.mjs';
 
 /**
  * Maximal minification (might break some pages)
- */
-export default { ...safePreset,
+ */ var max = {
+    ...safePreset,
     collapseWhitespace: 'all',
     removeComments: 'all',
     removeAttributeQuotes: true,
@@ -12,9 +12,11 @@ export default { ...safePreset,
     mergeStyles: true,
     removeUnusedCss: {},
     minifyCss: {
-        preset: 'default',
+        preset: 'default'
     },
     minifySvg: {},
     minifyConditionalComments: true,
-    removeOptionalTags: true,
+    removeOptionalTags: true
 };
+
+export { max as default };