htmlnano 3.0.0 → 3.2.0

package/dist/_modules/removeRedundantAttributes.js

@@ -1,5 +1,29 @@
 Object.defineProperty(exports, '__esModule', { value: true });
 
+function normalizeAttrValue(value) {
+    if (typeof value !== 'string') return null;
+    const trimmed = value.trim();
+    return trimmed.length === 0 ? '' : trimmed.toLowerCase();
+}
+function findAttrEntry(attrs, name) {
+    const targetName = name.toLowerCase();
+    for (const [attrName, attrValue] of Object.entries(attrs)){
+        if (attrName.toLowerCase() === targetName) {
+            return {
+                name: attrName,
+                value: attrValue
+            };
+        }
+    }
+    return null;
+}
+function getNormalizedAttrValue(attrs, name) {
+    const entry = findAttrEntry(attrs, name);
+    return entry ? normalizeAttrValue(entry.value) : null;
+}
+function hasAttr(attrs, name) {
+    return findAttrEntry(attrs, name) !== null;
+}
 // https://developer.mozilla.org/en-US/docs/Web/HTTP/Basics_of_HTTP/MIME_types#JavaScript_types
 const redundantScriptTypes = new Set([
     'application/javascript',
@@ -34,22 +58,14 @@ const missingValueDefaultAttributes = {
     script: {
         language: 'javascript',
         type: (attrs)=>{
-            for (const [attrName, attrValue] of Object.entries(attrs)){
-                if (attrName.toLowerCase() !== 'type') {
-                    continue;
-                }
-                if (typeof attrValue === 'string') {
-                    return redundantScriptTypes.has(attrValue);
-                }
-                return false;
-            }
-            return false;
+            const typeValue = getNormalizedAttrValue(attrs, 'type');
+            return typeValue !== null && redundantScriptTypes.has(typeValue);
         },
         // Remove attribute if the function returns false
         charset: (attrs)=>{
             // The charset attribute only really makes sense on “external” SCRIPT elements:
             // http://perfectionkills.com/optimizing-html/#8_script_charset
-            return !attrs.src;
+            return !hasAttr(attrs, 'src');
         }
     },
     style: {
@@ -60,19 +76,15 @@ const missingValueDefaultAttributes = {
         media: 'all',
         type: (attrs)=>{
             // https://html.spec.whatwg.org/multipage/links.html#link-type-stylesheet
-            let isRelStyleSheet = false;
-            let isTypeTextCSS = false;
-            if (attrs) {
-                for (const [attrName, attrValue] of Object.entries(attrs)){
-                    if (attrName.toLowerCase() === 'rel' && attrValue === 'stylesheet') {
-                        isRelStyleSheet = true;
-                    }
-                    if (attrName.toLowerCase() === 'type' && attrValue === 'text/css') {
-                        isTypeTextCSS = true;
-                    }
-                }
+            const relValue = getNormalizedAttrValue(attrs, 'rel');
+            const typeValue = getNormalizedAttrValue(attrs, 'type');
+            if (!relValue || !typeValue) {
+                return false;
             }
-            // Only "text/css" is redudant for link[rel=stylesheet]. Otherwise "type" shouldn't be removed
+            const relTokens = relValue.split(/\s+/);
+            const isRelStyleSheet = relTokens.includes('stylesheet');
+            const isTypeTextCSS = typeValue === 'text/css';
+            // Only "text/css" is redundant for link[rel=stylesheet]. Otherwise "type" shouldn't be removed
             return isRelStyleSheet && isTypeTextCSS;
         }
     },
@@ -104,18 +116,21 @@ const tagsHaveMissingValueDefaultAttributes = new Set(Object.keys(missingValueDe
         return (attrs, node)=>{
             if (!node.tag) return attrs;
             const newAttrs = attrs;
+            const attrsRecord = attrs;
             if (tagsHaveMissingValueDefaultAttributes.has(node.tag)) {
                 const tagRedundantAttributes = missingValueDefaultAttributes[node.tag];
                 for (const redundantAttributeName of Object.keys(tagRedundantAttributes)){
                     const tagRedundantAttributeValue = tagRedundantAttributes[redundantAttributeName];
                     let isRemove = false;
+                    const attrEntry = findAttrEntry(attrsRecord, redundantAttributeName);
                     if (typeof tagRedundantAttributeValue === 'function') {
-                        isRemove = tagRedundantAttributeValue(attrs);
-                    } else if (attrs[redundantAttributeName] === tagRedundantAttributeValue) {
-                        isRemove = true;
+                        isRemove = tagRedundantAttributeValue(attrsRecord);
+                    } else if (attrEntry) {
+                        const normalizedValue = normalizeAttrValue(attrEntry.value);
+                        isRemove = normalizedValue !== null && normalizedValue === tagRedundantAttributeValue;
                     }
-                    if (isRemove) {
-                        delete newAttrs[redundantAttributeName];
+                    if (isRemove && attrEntry) {
+                        delete newAttrs[attrEntry.name];
                     }
                 }
             }

package/dist/_modules/removeRedundantAttributes.mjs

@@ -1,3 +1,27 @@
+function normalizeAttrValue(value) {
+    if (typeof value !== 'string') return null;
+    const trimmed = value.trim();
+    return trimmed.length === 0 ? '' : trimmed.toLowerCase();
+}
+function findAttrEntry(attrs, name) {
+    const targetName = name.toLowerCase();
+    for (const [attrName, attrValue] of Object.entries(attrs)){
+        if (attrName.toLowerCase() === targetName) {
+            return {
+                name: attrName,
+                value: attrValue
+            };
+        }
+    }
+    return null;
+}
+function getNormalizedAttrValue(attrs, name) {
+    const entry = findAttrEntry(attrs, name);
+    return entry ? normalizeAttrValue(entry.value) : null;
+}
+function hasAttr(attrs, name) {
+    return findAttrEntry(attrs, name) !== null;
+}
 // https://developer.mozilla.org/en-US/docs/Web/HTTP/Basics_of_HTTP/MIME_types#JavaScript_types
 const redundantScriptTypes = new Set([
     'application/javascript',
@@ -32,22 +56,14 @@ const missingValueDefaultAttributes = {
     script: {
         language: 'javascript',
         type: (attrs)=>{
-            for (const [attrName, attrValue] of Object.entries(attrs)){
-                if (attrName.toLowerCase() !== 'type') {
-                    continue;
-                }
-                if (typeof attrValue === 'string') {
-                    return redundantScriptTypes.has(attrValue);
-                }
-                return false;
-            }
-            return false;
+            const typeValue = getNormalizedAttrValue(attrs, 'type');
+            return typeValue !== null && redundantScriptTypes.has(typeValue);
         },
         // Remove attribute if the function returns false
         charset: (attrs)=>{
             // The charset attribute only really makes sense on “external” SCRIPT elements:
             // http://perfectionkills.com/optimizing-html/#8_script_charset
-            return !attrs.src;
+            return !hasAttr(attrs, 'src');
         }
     },
     style: {
@@ -58,19 +74,15 @@ const missingValueDefaultAttributes = {
         media: 'all',
         type: (attrs)=>{
             // https://html.spec.whatwg.org/multipage/links.html#link-type-stylesheet
-            let isRelStyleSheet = false;
-            let isTypeTextCSS = false;
-            if (attrs) {
-                for (const [attrName, attrValue] of Object.entries(attrs)){
-                    if (attrName.toLowerCase() === 'rel' && attrValue === 'stylesheet') {
-                        isRelStyleSheet = true;
-                    }
-                    if (attrName.toLowerCase() === 'type' && attrValue === 'text/css') {
-                        isTypeTextCSS = true;
-                    }
-                }
+            const relValue = getNormalizedAttrValue(attrs, 'rel');
+            const typeValue = getNormalizedAttrValue(attrs, 'type');
+            if (!relValue || !typeValue) {
+                return false;
             }
-            // Only "text/css" is redudant for link[rel=stylesheet]. Otherwise "type" shouldn't be removed
+            const relTokens = relValue.split(/\s+/);
+            const isRelStyleSheet = relTokens.includes('stylesheet');
+            const isTypeTextCSS = typeValue === 'text/css';
+            // Only "text/css" is redundant for link[rel=stylesheet]. Otherwise "type" shouldn't be removed
             return isRelStyleSheet && isTypeTextCSS;
         }
     },
@@ -102,18 +114,21 @@ const tagsHaveMissingValueDefaultAttributes = new Set(Object.keys(missingValueDe
         return (attrs, node)=>{
             if (!node.tag) return attrs;
             const newAttrs = attrs;
+            const attrsRecord = attrs;
             if (tagsHaveMissingValueDefaultAttributes.has(node.tag)) {
                 const tagRedundantAttributes = missingValueDefaultAttributes[node.tag];
                 for (const redundantAttributeName of Object.keys(tagRedundantAttributes)){
                     const tagRedundantAttributeValue = tagRedundantAttributes[redundantAttributeName];
                     let isRemove = false;
+                    const attrEntry = findAttrEntry(attrsRecord, redundantAttributeName);
                     if (typeof tagRedundantAttributeValue === 'function') {
-                        isRemove = tagRedundantAttributeValue(attrs);
-                    } else if (attrs[redundantAttributeName] === tagRedundantAttributeValue) {
-                        isRemove = true;
+                        isRemove = tagRedundantAttributeValue(attrsRecord);
+                    } else if (attrEntry) {
+                        const normalizedValue = normalizeAttrValue(attrEntry.value);
+                        isRemove = normalizedValue !== null && normalizedValue === tagRedundantAttributeValue;
                     }
-                    if (isRemove) {
-                        delete newAttrs[redundantAttributeName];
+                    if (isRemove && attrEntry) {
+                        delete newAttrs[attrEntry.name];
                     }
                 }
             }

package/dist/_modules/removeUnusedCss.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';
 }
@@ -54,6 +87,7 @@ type HtmlnanoModule<Options = any> = {
 
 interface RemoveUnusedCssOptions {
     tool?: 'purgeCSS' | 'uncss';
+    [key: string]: unknown;
 }
 declare const mod: HtmlnanoModule<RemoveUnusedCssOptions>;
 

package/dist/_modules/removeUnusedCss.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';
 }
@@ -54,6 +87,7 @@ type HtmlnanoModule<Options = any> = {
 
 interface RemoveUnusedCssOptions {
     tool?: 'purgeCSS' | 'uncss';
+    [key: string]: unknown;
 }
 declare const mod: HtmlnanoModule<RemoveUnusedCssOptions>;
 

package/dist/_modules/removeUnusedCss.js

@@ -9,10 +9,12 @@ const uncssOptions = {
     ],
     stylesheets: []
 };
+// eslint-disable-next-line @typescript-eslint/no-explicit-any -- uncss has no types
 function processStyleNodeUnCSS(html, styleNode, uncssOptions, uncss) {
     const css = helpers_js.extractCssFromStyleNode(styleNode);
+    const { strippedCss, isCdataWrapped } = helpers_js.stripCssCdata(css);
     // eslint-disable-next-line @typescript-eslint/no-unsafe-argument -- uncss no types
-    return runUncss(html, css, uncssOptions, uncss).then((css)=>{
+    return runUncss(html, strippedCss, uncssOptions, uncss).then((css)=>{
         // uncss may have left some style tags empty
         if (css.trim().length === 0) {
             // @ts-expect-error -- explicitly remove the tag
@@ -21,10 +23,11 @@ function processStyleNodeUnCSS(html, styleNode, uncssOptions, uncss) {
             return;
         }
         styleNode.content = [
-            css
+            helpers_js.wrapCssCdata(css, isCdataWrapped)
         ];
     });
 }
+// eslint-disable-next-line @typescript-eslint/no-explicit-any -- uncss callback uses untyped args
 function runUncss(html, css, userOptions, uncss) {
     if (typeof userOptions !== 'object') {
         userOptions = {};
@@ -50,8 +53,8 @@ const purgeFromHtml = function(tree) {
     // making the process faster
     const selectors = [];
     tree.walk((node)=>{
-        const classes = node.attrs && node.attrs.class && node.attrs.class.split(' ') || [];
-        const ids = node.attrs && node.attrs.id && node.attrs.id.split(' ') || [];
+        const classes = getSelectorTokens(node.attrs && node.attrs.class);
+        const ids = getSelectorTokens(node.attrs && node.attrs.id);
         selectors.push(...classes, ...ids);
         if (node.tag) {
             selectors.push(node.tag);
@@ -60,9 +63,10 @@ const purgeFromHtml = function(tree) {
     });
     return ()=>selectors;
 };
-function processStyleNodePurgeCSS(tree, styleNode, purgecssOptions, purgecss) {
+function processStyleNodePurgeCSS(tree, styleNode, purgecssOptions, purgecss, extractor) {
     const css = helpers_js.extractCssFromStyleNode(styleNode);
-    return runPurgecss(tree, css, purgecssOptions, purgecss).then((css)=>{
+    const { strippedCss, isCdataWrapped } = helpers_js.stripCssCdata(css);
+    return runPurgecss(tree, strippedCss, purgecssOptions, purgecss, extractor).then((css)=>{
         if (css.trim().length === 0) {
             // @ts-expect-error -- explicitly remove the tag
             styleNode.tag = false;
@@ -70,11 +74,11 @@ function processStyleNodePurgeCSS(tree, styleNode, purgecssOptions, purgecss) {
             return;
         }
         styleNode.content = [
-            css
+            helpers_js.wrapCssCdata(css, isCdataWrapped)
         ];
     });
 }
-function runPurgecss(tree, css, userOptions, purgecss) {
+function runPurgecss(tree, css, userOptions, purgecss, extractor) {
     if (typeof userOptions !== 'object') {
         userOptions = {};
     }
@@ -95,7 +99,7 @@ function runPurgecss(tree, css, userOptions, purgecss) {
         ],
         extractors: [
             {
-                extractor: purgeFromHtml(tree),
+                extractor,
                 extensions: [
                     'html'
                 ]
@@ -108,20 +112,26 @@ function runPurgecss(tree, css, userOptions, purgecss) {
 }
 /** Remove unused CSS */ const mod = {
     async default (tree, options, userOptions) {
+        var _resolvedOptions_tool;
         const promises = [];
         let html;
+        let extractor;
         const purgecss = await helpers_js.optionalImport('purgecss');
         const uncss = await helpers_js.optionalImport('uncss');
+        const resolvedOptions = resolveUserOptions(userOptions);
+        const tool = (_resolvedOptions_tool = resolvedOptions.tool) != null ? _resolvedOptions_tool : 'purgeCSS';
+        const toolOptions = stripToolOption(resolvedOptions);
         tree.walk((node)=>{
-            if (helpers_js.isStyleNode(node)) {
-                if (userOptions.tool === 'purgeCSS') {
+            if (helpers_js.isStyleNode(node) && helpers_js.isCssStyleType(node)) {
+                if (tool === 'purgeCSS') {
                     if (purgecss) {
-                        promises.push(processStyleNodePurgeCSS(tree, node, userOptions, purgecss));
+                        extractor != null ? extractor : extractor = purgeFromHtml(tree);
+                        promises.push(processStyleNodePurgeCSS(tree, node, toolOptions, purgecss, extractor));
                     }
-                } else {
+                } else if (tool === 'uncss') {
                     if (uncss) {
                         html != null ? html : html = tree.render(tree);
-                        promises.push(processStyleNodeUnCSS(html, node, userOptions, uncss));
+                        promises.push(processStyleNodeUnCSS(html, node, toolOptions, uncss));
                     }
                 }
             }
@@ -130,5 +140,21 @@ function runPurgecss(tree, css, userOptions, purgecss) {
         return Promise.all(promises).then(()=>tree);
     }
 };
+function getSelectorTokens(value) {
+    if (typeof value !== 'string') {
+        return [];
+    }
+    return value.split(/\s+/).filter(Boolean);
+}
+function resolveUserOptions(userOptions) {
+    if (userOptions && typeof userOptions === 'object') {
+        return userOptions;
+    }
+    return {};
+}
+function stripToolOption(options) {
+    const { tool: _tool, ...rest } = options;
+    return rest;
+}
 
 exports.default = mod;

package/dist/_modules/removeUnusedCss.mjs

@@ -1,4 +1,4 @@
-import { optionalImport, isStyleNode, extractCssFromStyleNode } from '../helpers.mjs';
+import { optionalImport, isStyleNode, isCssStyleType, extractCssFromStyleNode, stripCssCdata, wrapCssCdata } from '../helpers.mjs';
 
 // These options must be set and shouldn't be overriden to ensure uncss doesn't look at linked stylesheets.
 const uncssOptions = {
@@ -7,10 +7,12 @@ const uncssOptions = {
     ],
     stylesheets: []
 };
+// eslint-disable-next-line @typescript-eslint/no-explicit-any -- uncss has no types
 function processStyleNodeUnCSS(html, styleNode, uncssOptions, uncss) {
     const css = extractCssFromStyleNode(styleNode);
+    const { strippedCss, isCdataWrapped } = stripCssCdata(css);
     // eslint-disable-next-line @typescript-eslint/no-unsafe-argument -- uncss no types
-    return runUncss(html, css, uncssOptions, uncss).then((css)=>{
+    return runUncss(html, strippedCss, uncssOptions, uncss).then((css)=>{
         // uncss may have left some style tags empty
         if (css.trim().length === 0) {
             // @ts-expect-error -- explicitly remove the tag
@@ -19,10 +21,11 @@ function processStyleNodeUnCSS(html, styleNode, uncssOptions, uncss) {
             return;
         }
         styleNode.content = [
-            css
+            wrapCssCdata(css, isCdataWrapped)
         ];
     });
 }
+// eslint-disable-next-line @typescript-eslint/no-explicit-any -- uncss callback uses untyped args
 function runUncss(html, css, userOptions, uncss) {
     if (typeof userOptions !== 'object') {
         userOptions = {};
@@ -48,8 +51,8 @@ const purgeFromHtml = function(tree) {
     // making the process faster
     const selectors = [];
     tree.walk((node)=>{
-        const classes = node.attrs && node.attrs.class && node.attrs.class.split(' ') || [];
-        const ids = node.attrs && node.attrs.id && node.attrs.id.split(' ') || [];
+        const classes = getSelectorTokens(node.attrs && node.attrs.class);
+        const ids = getSelectorTokens(node.attrs && node.attrs.id);
         selectors.push(...classes, ...ids);
         if (node.tag) {
             selectors.push(node.tag);
@@ -58,9 +61,10 @@ const purgeFromHtml = function(tree) {
     });
     return ()=>selectors;
 };
-function processStyleNodePurgeCSS(tree, styleNode, purgecssOptions, purgecss) {
+function processStyleNodePurgeCSS(tree, styleNode, purgecssOptions, purgecss, extractor) {
     const css = extractCssFromStyleNode(styleNode);
-    return runPurgecss(tree, css, purgecssOptions, purgecss).then((css)=>{
+    const { strippedCss, isCdataWrapped } = stripCssCdata(css);
+    return runPurgecss(tree, strippedCss, purgecssOptions, purgecss, extractor).then((css)=>{
         if (css.trim().length === 0) {
             // @ts-expect-error -- explicitly remove the tag
             styleNode.tag = false;
@@ -68,11 +72,11 @@ function processStyleNodePurgeCSS(tree, styleNode, purgecssOptions, purgecss) {
             return;
         }
         styleNode.content = [
-            css
+            wrapCssCdata(css, isCdataWrapped)
         ];
     });
 }
-function runPurgecss(tree, css, userOptions, purgecss) {
+function runPurgecss(tree, css, userOptions, purgecss, extractor) {
     if (typeof userOptions !== 'object') {
         userOptions = {};
     }
@@ -93,7 +97,7 @@ function runPurgecss(tree, css, userOptions, purgecss) {
         ],
         extractors: [
             {
-                extractor: purgeFromHtml(tree),
+                extractor,
                 extensions: [
                     'html'
                 ]
@@ -106,20 +110,26 @@ function runPurgecss(tree, css, userOptions, purgecss) {
 }
 /** Remove unused CSS */ const mod = {
     async default (tree, options, userOptions) {
+        var _resolvedOptions_tool;
         const promises = [];
         let html;
+        let extractor;
         const purgecss = await optionalImport('purgecss');
         const uncss = await optionalImport('uncss');
+        const resolvedOptions = resolveUserOptions(userOptions);
+        const tool = (_resolvedOptions_tool = resolvedOptions.tool) != null ? _resolvedOptions_tool : 'purgeCSS';
+        const toolOptions = stripToolOption(resolvedOptions);
         tree.walk((node)=>{
-            if (isStyleNode(node)) {
-                if (userOptions.tool === 'purgeCSS') {
+            if (isStyleNode(node) && isCssStyleType(node)) {
+                if (tool === 'purgeCSS') {
                     if (purgecss) {
-                        promises.push(processStyleNodePurgeCSS(tree, node, userOptions, purgecss));
+                        extractor != null ? extractor : extractor = purgeFromHtml(tree);
+                        promises.push(processStyleNodePurgeCSS(tree, node, toolOptions, purgecss, extractor));
                     }
-                } else {
+                } else if (tool === 'uncss') {
                     if (uncss) {
                         html != null ? html : html = tree.render(tree);
-                        promises.push(processStyleNodeUnCSS(html, node, userOptions, uncss));
+                        promises.push(processStyleNodeUnCSS(html, node, toolOptions, uncss));
                     }
                 }
             }
@@ -128,5 +138,21 @@ function runPurgecss(tree, css, userOptions, purgecss) {
         return Promise.all(promises).then(()=>tree);
     }
 };
+function getSelectorTokens(value) {
+    if (typeof value !== 'string') {
+        return [];
+    }
+    return value.split(/\s+/).filter(Boolean);
+}
+function resolveUserOptions(userOptions) {
+    if (userOptions && typeof userOptions === 'object') {
+        return userOptions;
+    }
+    return {};
+}
+function stripToolOption(options) {
+    const { tool: _tool, ...rest } = options;
+    return rest;
+}
 
 export { mod as default };