htmlnano 2.1.1 → 2.1.3

package/dist/_modules/sortAttributes.js

@@ -0,0 +1,102 @@
+Object.defineProperty(exports, '__esModule', { value: true });
+
+const validOptions = new Set([
+    'frequency',
+    'alphabetical'
+]);
+const processModuleOptions = (options)=>{
+    if (options === true) return 'alphabetical';
+    if (options === false) return false;
+    return validOptions.has(options) ? options : false;
+};
+class AttributeTokenChain {
+    addFromNodeAttrs(nodeAttrs) {
+        Object.keys(nodeAttrs).forEach((attrName)=>{
+            const attrNameLower = attrName.toLowerCase();
+            if (this.freqData.has(attrNameLower)) {
+                this.freqData.set(attrNameLower, this.freqData.get(attrNameLower) + 1);
+            } else {
+                this.freqData.set(attrNameLower, 1);
+            }
+        });
+    }
+    createSortOrder() {
+        const _sortOrder = [
+            ...this.freqData.entries()
+        ];
+        _sortOrder.sort((a, b)=>b[1] - a[1]);
+        this.sortOrder = _sortOrder.map((i)=>i[0]);
+    }
+    sortFromNodeAttrs(nodeAttrs) {
+        const newAttrs = {};
+        // Convert node.attrs attrName into lower case.
+        const loweredNodeAttrs = {};
+        Object.entries(nodeAttrs).forEach(([attrName, attrValue])=>{
+            loweredNodeAttrs[attrName.toLowerCase()] = attrValue;
+        });
+        if (!this.sortOrder) {
+            this.createSortOrder();
+        }
+        this.sortOrder.forEach((attrNameLower)=>{
+            // The attrName inside "sortOrder" has been lowered
+            if (loweredNodeAttrs[attrNameLower] != null) {
+                newAttrs[attrNameLower] = loweredNodeAttrs[attrNameLower];
+            }
+        });
+        return newAttrs;
+    }
+    constructor(){
+        /** <attr, frequency> */ this.freqData = new Map();
+        this.sortOrder = null;
+    }
+}
+/** Sort attibutes */ const mod = {
+    default (tree, options, moduleOptions) {
+        const sortType = processModuleOptions(moduleOptions);
+        if (sortType === 'alphabetical') {
+            return sortAttributesInAlphabeticalOrder(tree);
+        }
+        if (sortType === 'frequency') {
+            return sortAttributesByFrequency(tree);
+        }
+        // Invalid configuration
+        return tree;
+    }
+};
+function sortAttributesInAlphabeticalOrder(tree) {
+    tree.walk((node)=>{
+        if (!node.attrs) {
+            return node;
+        }
+        const newAttrs = {};
+        Object.keys(node.attrs)// @ts-expect-error -- deliberately use minus operator to sort things
+        .sort((a, b)=>typeof a.localeCompare === 'function' ? a.localeCompare(b) : a - b).forEach((attr)=>{
+            newAttrs[attr] = node.attrs[attr];
+        });
+        node.attrs = newAttrs;
+        return node;
+    });
+    return tree;
+}
+function sortAttributesByFrequency(tree) {
+    const tokenchain = new AttributeTokenChain();
+    // Traverse through tree to get frequency
+    tree.walk((node)=>{
+        if (!node.attrs) {
+            return node;
+        }
+        tokenchain.addFromNodeAttrs(node.attrs);
+        return node;
+    });
+    // Traverse through tree again, this time sort the attributes
+    tree.walk((node)=>{
+        if (!node.attrs) {
+            return node;
+        }
+        node.attrs = tokenchain.sortFromNodeAttrs(node.attrs);
+        return node;
+    });
+    return tree;
+}
+
+exports.default = mod;

package/{lib/modules → dist/_modules}/sortAttributes.mjs

@@ -1,22 +1,16 @@
-import { sort as timSort } from 'timsort';
-
-const validOptions = new Set(['frequency', 'alphabetical']);
-
-const processModuleOptions = options => {
+const validOptions = new Set([
+    'frequency',
+    'alphabetical'
+]);
+const processModuleOptions = (options)=>{
     if (options === true) return 'alphabetical';
-
+    if (options === false) return false;
     return validOptions.has(options) ? options : false;
 };
-
 class AttributeTokenChain {
-    constructor() {
-        this.freqData = new Map(); // <attr, frequency>[]
-    }
-
     addFromNodeAttrs(nodeAttrs) {
-        Object.keys(nodeAttrs).forEach(attrName => {
+        Object.keys(nodeAttrs).forEach((attrName)=>{
             const attrNameLower = attrName.toLowerCase();
-
             if (this.freqData.has(attrNameLower)) {
                 this.freqData.set(attrNameLower, this.freqData.get(attrNameLower) + 1);
             } else {
@@ -24,98 +18,83 @@ class AttributeTokenChain {
             }
         });
     }
-
     createSortOrder() {
-        let _sortOrder = [...this.freqData.entries()];
-        timSort(_sortOrder, (a, b) => b[1] - a[1]);
-
-        this.sortOrder = _sortOrder.map(i => i[0]);
+        const _sortOrder = [
+            ...this.freqData.entries()
+        ];
+        _sortOrder.sort((a, b)=>b[1] - a[1]);
+        this.sortOrder = _sortOrder.map((i)=>i[0]);
     }
-
     sortFromNodeAttrs(nodeAttrs) {
         const newAttrs = {};
-
         // Convert node.attrs attrName into lower case.
         const loweredNodeAttrs = {};
-        Object.entries(nodeAttrs).forEach(([attrName, attrValue]) => {
+        Object.entries(nodeAttrs).forEach(([attrName, attrValue])=>{
             loweredNodeAttrs[attrName.toLowerCase()] = attrValue;
         });
-
         if (!this.sortOrder) {
             this.createSortOrder();
         }
-
-        this.sortOrder.forEach(attrNameLower => {
+        this.sortOrder.forEach((attrNameLower)=>{
             // The attrName inside "sortOrder" has been lowered
             if (loweredNodeAttrs[attrNameLower] != null) {
                 newAttrs[attrNameLower] = loweredNodeAttrs[attrNameLower];
             }
         });
-
         return newAttrs;
     }
-}
-
-/** Sort attibutes */
-export default function sortAttributes(tree, options, moduleOptions) {
-    const sortType = processModuleOptions(moduleOptions);
-
-    if (sortType === 'alphabetical') {
-        return sortAttributesInAlphabeticalOrder(tree);
-    }
-
-    if (sortType === 'frequency') {
-        return sortAttributesByFrequency(tree);
+    constructor(){
+        /** <attr, frequency> */ this.freqData = new Map();
+        this.sortOrder = null;
     }
-
-    // Invalid configuration
-    return tree;
 }
-
+/** Sort attibutes */ const mod = {
+    default (tree, options, moduleOptions) {
+        const sortType = processModuleOptions(moduleOptions);
+        if (sortType === 'alphabetical') {
+            return sortAttributesInAlphabeticalOrder(tree);
+        }
+        if (sortType === 'frequency') {
+            return sortAttributesByFrequency(tree);
+        }
+        // Invalid configuration
+        return tree;
+    }
+};
 function sortAttributesInAlphabeticalOrder(tree) {
-    tree.walk(node => {
+    tree.walk((node)=>{
         if (!node.attrs) {
             return node;
         }
-
         const newAttrs = {};
-
-        Object.keys(node.attrs)
-            .sort((a, b) => typeof a.localeCompare === 'function' ? a.localeCompare(b) : a - b)
-            .forEach(attr => newAttrs[attr] = node.attrs[attr]);
-
+        Object.keys(node.attrs)// @ts-expect-error -- deliberately use minus operator to sort things
+        .sort((a, b)=>typeof a.localeCompare === 'function' ? a.localeCompare(b) : a - b).forEach((attr)=>{
+            newAttrs[attr] = node.attrs[attr];
+        });
         node.attrs = newAttrs;
-
         return node;
     });
-
     return tree;
 }
-
 function sortAttributesByFrequency(tree) {
     const tokenchain = new AttributeTokenChain();
-
     // Traverse through tree to get frequency
-    tree.walk(node => {
+    tree.walk((node)=>{
         if (!node.attrs) {
             return node;
         }
-
         tokenchain.addFromNodeAttrs(node.attrs);
-
         return node;
     });
-
     // Traverse through tree again, this time sort the attributes
-    tree.walk(node => {
+    tree.walk((node)=>{
         if (!node.attrs) {
             return node;
         }
-
         node.attrs = tokenchain.sortFromNodeAttrs(node.attrs);
-
         return node;
     });
-
     return tree;
 }
+
+export { mod as default };

package/dist/_modules/sortAttributesWithLists.d.mts

@@ -0,0 +1,56 @@
+import PostHTML from 'posthtml';
+import { MinifyOptions } from 'terser';
+import { Options } from 'cssnano';
+import { Config } from 'svgo';
+
+type PostHTMLTreeLike = [PostHTML.Node] & PostHTML.NodeAPI & {
+    options?: {
+        quoteAllAttributes?: boolean | undefined;
+    } | undefined;
+    render(): string;
+    render(node: PostHTML.Node | PostHTMLTreeLike, renderOptions?: any): string;
+};
+type MaybeArray<T> = T | Array<T>;
+type PostHTMLNodeLike = PostHTML.Node | string;
+interface HtmlnanoOptions {
+    skipConfigLoading?: boolean;
+    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;
+    minifyConditionalComments?: boolean;
+    minifyJs?: MinifyOptions | boolean;
+    minifyJson?: boolean;
+    minifySvg?: Config | boolean;
+    normalizeAttributeValues?: boolean;
+    removeAttributeQuotes?: boolean;
+    removeComments?: boolean | 'safe' | 'all' | RegExp | ((comment: string) => boolean);
+    removeEmptyAttributes?: boolean;
+    removeRedundantAttributes?: boolean;
+    removeOptionalTags?: boolean;
+    removeUnusedCss?: boolean;
+    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>;
+};
+
+declare const mod: HtmlnanoModule<boolean | 'alphabetical' | 'frequency'>;
+
+export { mod as default };

package/dist/_modules/sortAttributesWithLists.d.ts

@@ -0,0 +1,56 @@
+import PostHTML from 'posthtml';
+import { MinifyOptions } from 'terser';
+import { Options } from 'cssnano';
+import { Config } from 'svgo';
+
+type PostHTMLTreeLike = [PostHTML.Node] & PostHTML.NodeAPI & {
+    options?: {
+        quoteAllAttributes?: boolean | undefined;
+    } | undefined;
+    render(): string;
+    render(node: PostHTML.Node | PostHTMLTreeLike, renderOptions?: any): string;
+};
+type MaybeArray<T> = T | Array<T>;
+type PostHTMLNodeLike = PostHTML.Node | string;
+interface HtmlnanoOptions {
+    skipConfigLoading?: boolean;
+    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;
+    minifyConditionalComments?: boolean;
+    minifyJs?: MinifyOptions | boolean;
+    minifyJson?: boolean;
+    minifySvg?: Config | boolean;
+    normalizeAttributeValues?: boolean;
+    removeAttributeQuotes?: boolean;
+    removeComments?: boolean | 'safe' | 'all' | RegExp | ((comment: string) => boolean);
+    removeEmptyAttributes?: boolean;
+    removeRedundantAttributes?: boolean;
+    removeOptionalTags?: boolean;
+    removeUnusedCss?: boolean;
+    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>;
+};
+
+declare const mod: HtmlnanoModule<boolean | 'alphabetical' | 'frequency'>;
+
+export { mod as default };

package/dist/_modules/sortAttributesWithLists.js

@@ -0,0 +1,118 @@
+Object.defineProperty(exports, '__esModule', { value: true });
+
+var collapseAttributeWhitespace_js = require('./collapseAttributeWhitespace.js');
+
+// class, rel, ping
+const validOptions = new Set([
+    'frequency',
+    'alphabetical'
+]);
+const processModuleOptions = (options)=>{
+    if (options === true) return 'alphabetical';
+    if (options === false) return false;
+    return validOptions.has(options) ? options : false;
+};
+class AttributeTokenChain {
+    addFromNodeAttrsArray(attrValuesArray) {
+        attrValuesArray.forEach((attrValue)=>{
+            if (this.freqData.has(attrValue)) {
+                this.freqData.set(attrValue, this.freqData.get(attrValue) + 1);
+            } else {
+                this.freqData.set(attrValue, 1);
+            }
+        });
+    }
+    createSortOrder() {
+        const _sortOrder = [
+            ...this.freqData.entries()
+        ];
+        _sortOrder.sort((a, b)=>b[1] - a[1]);
+        this.sortOrder = _sortOrder.map((i)=>i[0]);
+    }
+    sortFromNodeAttrsArray(attrValuesArray) {
+        const resultArray = [];
+        if (!this.sortOrder) {
+            this.createSortOrder();
+        }
+        this.sortOrder.forEach((k)=>{
+            if (attrValuesArray.includes(k)) {
+                resultArray.push(k);
+            }
+        });
+        return resultArray;
+    }
+    constructor(){
+        /** <attr, frequency> */ this.freqData = new Map();
+        this.sortOrder = null;
+    }
+}
+/** Sort values inside list-like attributes (e.g. class, rel) */ const mod = {
+    default (tree, options, moduleOptions) {
+        const sortType = processModuleOptions(moduleOptions);
+        if (sortType === 'alphabetical') {
+            return sortAttributesWithListsInAlphabeticalOrder(tree);
+        }
+        if (sortType === 'frequency') {
+            return sortAttributesWithListsByFrequency(tree);
+        }
+        // Invalid configuration
+        return tree;
+    }
+};
+function sortAttributesWithListsInAlphabeticalOrder(tree) {
+    tree.walk((node)=>{
+        if (!node.attrs) {
+            return node;
+        }
+        Object.keys(node.attrs).forEach((attrName)=>{
+            const attrNameLower = attrName.toLowerCase();
+            if (!collapseAttributeWhitespace_js.attributesWithLists.has(attrNameLower)) {
+                return;
+            }
+            const attrValues = node.attrs[attrName].split(/\s/);
+            node.attrs[attrName] = attrValues.sort((a, b)=>{
+                // @ts-expect-error -- deliberately use minus operator to sort things
+                return typeof a.localeCompare === 'function' ? a.localeCompare(b) : a - b;
+            }).join(' ');
+        });
+        return node;
+    });
+    return tree;
+}
+function sortAttributesWithListsByFrequency(tree) {
+    const tokenChainObj = {}; // <attrNameLower: AttributeTokenChain>[]
+    // Traverse through tree to get frequency
+    tree.walk((node)=>{
+        if (!node.attrs) {
+            return node;
+        }
+        Object.entries(node.attrs).forEach(([attrName, attrValues])=>{
+            const attrNameLower = attrName.toLowerCase();
+            if (!collapseAttributeWhitespace_js.attributesWithLists.has(attrNameLower)) {
+                return;
+            }
+            tokenChainObj[attrNameLower] = tokenChainObj[attrNameLower] || new AttributeTokenChain();
+            tokenChainObj[attrNameLower].addFromNodeAttrsArray(attrValues.split(/\s/));
+        });
+        return node;
+    });
+    // Traverse through tree again, this time sort the attribute values
+    tree.walk((node)=>{
+        if (!node.attrs) {
+            return node;
+        }
+        Object.entries(node.attrs).forEach(([attrName, attrValues])=>{
+            const attrNameLower = attrName.toLowerCase();
+            if (!collapseAttributeWhitespace_js.attributesWithLists.has(attrNameLower)) {
+                return;
+            }
+            if (tokenChainObj[attrNameLower]) {
+                node.attrs[attrName] = tokenChainObj[attrNameLower].sortFromNodeAttrsArray(attrValues.split(/\s/)).join(' ');
+            }
+        });
+        return node;
+    });
+    return tree;
+}
+
+exports.default = mod;

package/{lib/modules → dist/_modules}/sortAttributesWithLists.mjs

@@ -1,21 +1,18 @@
-// class, rel, ping
-import { sort as timSort } from 'timsort';
 import { attributesWithLists } from './collapseAttributeWhitespace.mjs';
 
-const validOptions = new Set(['frequency', 'alphabetical']);
-const processModuleOptions = options => {
+// class, rel, ping
+const validOptions = new Set([
+    'frequency',
+    'alphabetical'
+]);
+const processModuleOptions = (options)=>{
     if (options === true) return 'alphabetical';
-
+    if (options === false) return false;
     return validOptions.has(options) ? options : false;
 };
-
 class AttributeTokenChain {
-    constructor() {
-        this.freqData = new Map(); // <attrValue, frequency>[]
-    }
-
     addFromNodeAttrsArray(attrValuesArray) {
-        attrValuesArray.forEach(attrValue => {
+        attrValuesArray.forEach((attrValue)=>{
             if (this.freqData.has(attrValue)) {
                 this.freqData.set(attrValue, this.freqData.get(attrValue) + 1);
             } else {
@@ -23,113 +20,97 @@ class AttributeTokenChain {
             }
         });
     }
-
     createSortOrder() {
-        let _sortOrder = [...this.freqData.entries()];
-        timSort(_sortOrder, (a, b) => b[1] - a[1]);
-
-        this.sortOrder = _sortOrder.map(i => i[0]);
+        const _sortOrder = [
+            ...this.freqData.entries()
+        ];
+        _sortOrder.sort((a, b)=>b[1] - a[1]);
+        this.sortOrder = _sortOrder.map((i)=>i[0]);
     }
-
     sortFromNodeAttrsArray(attrValuesArray) {
         const resultArray = [];
-
         if (!this.sortOrder) {
             this.createSortOrder();
         }
-
-        this.sortOrder.forEach(k => {
+        this.sortOrder.forEach((k)=>{
             if (attrValuesArray.includes(k)) {
                 resultArray.push(k);
             }
         });
-
         return resultArray;
     }
-}
-
-/** Sort values inside list-like attributes (e.g. class, rel) */
-export default function collapseAttributeWhitespace(tree, options, moduleOptions) {
-    const sortType = processModuleOptions(moduleOptions);
-
-    if (sortType === 'alphabetical') {
-        return sortAttributesWithListsInAlphabeticalOrder(tree);
-    }
-
-    if (sortType === 'frequency') {
-        return sortAttributesWithListsByFrequency(tree);
+    constructor(){
+        /** <attr, frequency> */ this.freqData = new Map();
+        this.sortOrder = null;
     }
-
-    // Invalid configuration
-    return tree;
 }
-
+/** Sort values inside list-like attributes (e.g. class, rel) */ const mod = {
+    default (tree, options, moduleOptions) {
+        const sortType = processModuleOptions(moduleOptions);
+        if (sortType === 'alphabetical') {
+            return sortAttributesWithListsInAlphabeticalOrder(tree);
+        }
+        if (sortType === 'frequency') {
+            return sortAttributesWithListsByFrequency(tree);
+        }
+        // Invalid configuration
+        return tree;
+    }
+};
 function sortAttributesWithListsInAlphabeticalOrder(tree) {
-    tree.walk(node => {
+    tree.walk((node)=>{
         if (!node.attrs) {
             return node;
         }
-
-        Object.keys(node.attrs).forEach(attrName => {
+        Object.keys(node.attrs).forEach((attrName)=>{
             const attrNameLower = attrName.toLowerCase();
             if (!attributesWithLists.has(attrNameLower)) {
                 return;
             }
-
             const attrValues = node.attrs[attrName].split(/\s/);
-
-            node.attrs[attrName] = attrValues.sort((a, b) => {
+            node.attrs[attrName] = attrValues.sort((a, b)=>{
+                // @ts-expect-error -- deliberately use minus operator to sort things
                 return typeof a.localeCompare === 'function' ? a.localeCompare(b) : a - b;
             }).join(' ');
         });
-
         return node;
     });
-
     return tree;
 }
-
 function sortAttributesWithListsByFrequency(tree) {
     const tokenChainObj = {}; // <attrNameLower: AttributeTokenChain>[]
-
     // Traverse through tree to get frequency
-    tree.walk(node => {
+    tree.walk((node)=>{
         if (!node.attrs) {
             return node;
         }
-
-        Object.entries(node.attrs).forEach(([attrName, attrValues]) => {
+        Object.entries(node.attrs).forEach(([attrName, attrValues])=>{
             const attrNameLower = attrName.toLowerCase();
-
             if (!attributesWithLists.has(attrNameLower)) {
                 return;
             }
-
             tokenChainObj[attrNameLower] = tokenChainObj[attrNameLower] || new AttributeTokenChain();
             tokenChainObj[attrNameLower].addFromNodeAttrsArray(attrValues.split(/\s/));
         });
-
         return node;
     });
-
     // Traverse through tree again, this time sort the attribute values
-    tree.walk(node => {
+    tree.walk((node)=>{
         if (!node.attrs) {
             return node;
         }
-
-        Object.entries(node.attrs).forEach(([attrName, attrValues]) => {
+        Object.entries(node.attrs).forEach(([attrName, attrValues])=>{
             const attrNameLower = attrName.toLowerCase();
-
             if (!attributesWithLists.has(attrNameLower)) {
                 return;
             }
-
             if (tokenChainObj[attrNameLower]) {
                 node.attrs[attrName] = tokenChainObj[attrNameLower].sortFromNodeAttrsArray(attrValues.split(/\s/)).join(' ');
             }
         });
-
         return node;
     });
+    return tree;
 }
+
+export { mod as default };