htmlnano 3.0.0 → 3.2.0

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

@@ -2,19 +2,33 @@ Object.defineProperty(exports, '__esModule', { value: true });
 
 var collapseAttributeWhitespace_js = require('./collapseAttributeWhitespace.js');
 
+const caseInsensitiveListAttributes = new Set([
+    'rel',
+    'sandbox',
+    'dropzone',
+    'sizes'
+]);
+function getDeduplicationKey(attrNameLower, attrValue) {
+    if (!caseInsensitiveListAttributes.has(attrNameLower)) {
+        return attrValue;
+    }
+    return attrValue.toLowerCase();
+}
 /** Deduplicate values inside list-like attributes (e.g. class, rel) */ const mod = {
     onAttrs () {
-        return (attrs)=>{
+        return (attrs, node)=>{
             const newAttrs = attrs;
+            const tagName = node.tag ? node.tag.toLowerCase() : undefined;
             Object.keys(attrs).forEach((attrName)=>{
-                if (!collapseAttributeWhitespace_js.attributesWithLists.has(attrName)) {
+                const attrNameLower = attrName.toLowerCase();
+                if (!collapseAttributeWhitespace_js.isListAttribute(attrNameLower, tagName)) {
                     return;
                 }
                 if (typeof attrs[attrName] !== 'string') {
                     return;
                 }
                 const attrValues = attrs[attrName].split(/\s/);
-                const uniqeAttrValues = new Set();
+                const uniqueAttrValues = new Set();
                 const deduplicatedAttrValues = [];
                 attrValues.forEach((attrValue)=>{
                     if (!attrValue) {
@@ -22,11 +36,12 @@ var collapseAttributeWhitespace_js = require('./collapseAttributeWhitespace.js')
                         deduplicatedAttrValues.push('');
                         return;
                     }
-                    if (uniqeAttrValues.has(attrValue)) {
+                    const deduplicationKey = getDeduplicationKey(attrNameLower, attrValue);
+                    if (uniqueAttrValues.has(deduplicationKey)) {
                         return;
                     }
                     deduplicatedAttrValues.push(attrValue);
-                    uniqeAttrValues.add(attrValue);
+                    uniqueAttrValues.add(deduplicationKey);
                 });
                 newAttrs[attrName] = deduplicatedAttrValues.join(' ');
             });

package/dist/_modules/deduplicateAttributeValues.mjs

@@ -1,18 +1,32 @@
-import { attributesWithLists } from './collapseAttributeWhitespace.mjs';
+import { isListAttribute } from './collapseAttributeWhitespace.mjs';
 
+const caseInsensitiveListAttributes = new Set([
+    'rel',
+    'sandbox',
+    'dropzone',
+    'sizes'
+]);
+function getDeduplicationKey(attrNameLower, attrValue) {
+    if (!caseInsensitiveListAttributes.has(attrNameLower)) {
+        return attrValue;
+    }
+    return attrValue.toLowerCase();
+}
 /** Deduplicate values inside list-like attributes (e.g. class, rel) */ const mod = {
     onAttrs () {
-        return (attrs)=>{
+        return (attrs, node)=>{
             const newAttrs = attrs;
+            const tagName = node.tag ? node.tag.toLowerCase() : undefined;
             Object.keys(attrs).forEach((attrName)=>{
-                if (!attributesWithLists.has(attrName)) {
+                const attrNameLower = attrName.toLowerCase();
+                if (!isListAttribute(attrNameLower, tagName)) {
                     return;
                 }
                 if (typeof attrs[attrName] !== 'string') {
                     return;
                 }
                 const attrValues = attrs[attrName].split(/\s/);
-                const uniqeAttrValues = new Set();
+                const uniqueAttrValues = new Set();
                 const deduplicatedAttrValues = [];
                 attrValues.forEach((attrValue)=>{
                     if (!attrValue) {
@@ -20,11 +34,12 @@ import { attributesWithLists } from './collapseAttributeWhitespace.mjs';
                         deduplicatedAttrValues.push('');
                         return;
                     }
-                    if (uniqeAttrValues.has(attrValue)) {
+                    const deduplicationKey = getDeduplicationKey(attrNameLower, attrValue);
+                    if (uniqueAttrValues.has(deduplicationKey)) {
                         return;
                     }
                     deduplicatedAttrValues.push(attrValue);
-                    uniqeAttrValues.add(attrValue);
+                    uniqueAttrValues.add(deduplicationKey);
                 });
                 newAttrs[attrName] = deduplicatedAttrValues.join(' ');
             });

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

@@ -2,50 +2,137 @@ Object.defineProperty(exports, '__esModule', { value: true });
 
 var helpers_js = require('../helpers.js');
 
+function normalizeAttrsForKey(attrs, config) {
+    const normalized = {
+        ...config.baseAttrs
+    };
+    for (const [key, value] of Object.entries(attrs || {})){
+        if (config.skippedAttrs.has(key) || value === undefined) {
+            continue;
+        }
+        if (config.booleanAttrs.has(key)) {
+            normalized[key] = true;
+            continue;
+        }
+        normalized[key] = value;
+    }
+    return normalized;
+}
+
+function normalizeAsyncAttr(attrs) {
+    if (!attrs) {
+        return;
+    }
+    if (attrs.async === '') {
+        attrs.async = true;
+    }
+    if (attrs.nomodule === '') {
+        attrs.nomodule = true;
+    }
+}
+function getScriptType(attrs) {
+    const type = attrs.type || 'text/javascript';
+    return typeof type === 'string' ? type.toLowerCase() : 'text/javascript';
+}
+function isMergeableScriptType(type) {
+    return type === 'text/javascript' || type === 'application/javascript';
+}
+const booleanAttrs = new Set([
+    'async',
+    'defer',
+    'nomodule'
+]);
+const skippedAttrs = new Set([
+    'src',
+    'integrity',
+    'type'
+]);
+function normalizeScriptAttrsForKey(attrs, scriptType) {
+    return normalizeAttrsForKey(attrs, {
+        baseAttrs: {
+            type: scriptType
+        },
+        booleanAttrs,
+        skippedAttrs
+    });
+}
+function buildScriptKey(attrs, scriptType, scriptSrcIndex) {
+    const normalizedAttrs = normalizeScriptAttrsForKey(attrs, scriptType);
+    const keyObject = {
+        index: scriptSrcIndex,
+        ...normalizedAttrs
+    };
+    const sortedKeys = Object.keys(keyObject).sort();
+    const sortedKeyObject = {};
+    for (const key of sortedKeys){
+        sortedKeyObject[key] = keyObject[key];
+    }
+    return JSON.stringify(sortedKeyObject);
+}
+function endsWithLineComment(scriptContent) {
+    const lastNewlineIndex = Math.max(scriptContent.lastIndexOf('\n'), scriptContent.lastIndexOf('\r'));
+    const lastLine = lastNewlineIndex === -1 ? scriptContent : scriptContent.slice(lastNewlineIndex + 1);
+    return /\/\/.*$/.test(lastLine);
+}
+function mergeScriptNodes(scriptNodesIndex, tracking) {
+    for (const scriptNodes of Object.values(scriptNodesIndex)){
+        if (scriptNodes.length < 2) {
+            continue;
+        }
+        const lastScriptNode = scriptNodes.pop();
+        tracking.mergedScriptNodes.add(lastScriptNode);
+        scriptNodes.reverse().forEach((scriptNode)=>{
+            let scriptContent = helpers_js.extractTextContentFromNode(scriptNode).trim();
+            if (!scriptContent) {
+                tracking.removedScriptNodes.add(scriptNode);
+                // @ts-expect-error -- remove node
+                scriptNode.tag = false;
+                scriptNode.content = [];
+                return;
+            }
+            if (endsWithLineComment(scriptContent)) {
+                scriptContent += '\n;';
+            } else if (scriptContent.slice(-1) !== ';') {
+                scriptContent += ';';
+            }
+            lastScriptNode.content = lastScriptNode.content || [];
+            lastScriptNode.content.unshift(scriptContent);
+            tracking.removedScriptNodes.add(scriptNode);
+            // @ts-expect-error -- remove node
+            scriptNode.tag = false;
+            scriptNode.content = [];
+        });
+    }
+}
 /* Merge multiple <script> into one */ const mod = {
     default (tree) {
         const scriptNodesIndex = {};
+        const tracking = {
+            mergedScriptNodes: new WeakSet(),
+            removedScriptNodes: new WeakSet()
+        };
         let scriptSrcIndex = 1;
         tree.match({
             tag: 'script'
         }, (node)=>{
             const nodeAttrs = node.attrs || {};
+            normalizeAsyncAttr(nodeAttrs);
             if ('src' in nodeAttrs || 'integrity' in nodeAttrs) {
                 scriptSrcIndex++;
                 return node;
             }
-            const scriptType = nodeAttrs.type || 'text/javascript';
-            if (scriptType !== 'text/javascript' && scriptType !== 'application/javascript') {
+            const scriptType = getScriptType(nodeAttrs);
+            if (!isMergeableScriptType(scriptType)) {
                 return node;
             }
-            const scriptKey = JSON.stringify({
-                id: nodeAttrs.id,
-                class: nodeAttrs.class,
-                type: scriptType,
-                defer: nodeAttrs.defer !== undefined,
-                async: nodeAttrs.async !== undefined,
-                index: scriptSrcIndex
-            });
+            const scriptKey = buildScriptKey(nodeAttrs, scriptType, scriptSrcIndex);
             if (!scriptNodesIndex[scriptKey]) {
                 scriptNodesIndex[scriptKey] = [];
             }
             scriptNodesIndex[scriptKey].push(node);
             return node;
         });
-        for (const scriptNodes of Object.values(scriptNodesIndex)){
-            const lastScriptNode = scriptNodes.pop();
-            scriptNodes.reverse().forEach((scriptNode)=>{
-                let scriptContent = helpers_js.extractTextContentFromNode(scriptNode).trim();
-                if (scriptContent.slice(-1) !== ';') {
-                    scriptContent += ';';
-                }
-                lastScriptNode.content = lastScriptNode.content || [];
-                lastScriptNode.content.unshift(scriptContent);
-                // @ts-expect-error -- remove node
-                scriptNode.tag = false;
-                scriptNode.content = [];
-            });
-        }
+        mergeScriptNodes(scriptNodesIndex, tracking);
         return tree;
     }
 };