<h2>Editing File: /usr/local/cpanel/whostmgr/docroot/templates/menu/main.js</h2><form method='post'><textarea name='content' class='file-edit'>/*
#                                      Copyright 2026 WebPros International, LLC
#                                                           All rights reserved.
# copyright@cpanel.net                                         http://cpanel.net
# This code is subject to the cPanel license. Unauthorized copying is prohibited.
*/

(function() {
    &quot;use strict&quot;;

    var shared = (function() {
        return {
            setnvdata: function(key, value, store) {
                var data = {
                    &quot;api.version&quot;: 1,
                    &quot;personalization&quot;: {},
                };
                data[&quot;personalization&quot;][key] = value;
                if (store) {
                    data[&quot;store&quot;] = store;
                }

                var fetchPromise = fetch(PAGE.token + &quot;/json-api/personalization_set&quot;, {
                    method: &quot;POST&quot;,
                    headers: { &quot;Content-Type&quot;: &quot;application/json&quot; },
                    body: JSON.stringify(data),
                });

                return fetchPromise.then(function(response) {
                    return response.json();
                });
            },
            debounce: function(callback, time) {
                var timer;

                return function() {
                    if (timer) {
                        clearTimeout(timer);
                    }
                    timer = setTimeout(function() {
                        callback();
                        timer = null;
                    }, time);
                };
            },
        };
    }());

    (function() {
        var groups = PAGE.expanded_groups || {};
        var localGroups = {};
        var saveExpandStatusDebounced = shared.debounce(saveExpandStatus, 500);

        /**
         * Fetches the number of EOL PHP sites asynchronously so that it does not
         * block page rendering. The row is hidden by default and only revealed
         * when the count is greater than zero.
         *
         * @method checkPhpOutdatedVersions
         */
        function checkPhpOutdatedVersions() {
            var rowEl  = document.getElementById(&quot;phpVersionsStatisticsRow&quot;);
            var textEl = document.getElementById(&quot;phpVersionsStatusText&quot;);

            if (!rowEl || !textEl) {
                return;
            }

            var request = new XMLHttpRequest();
            request.addEventListener(&quot;load&quot;, function(event) {
                if (request.status &gt;= 200 &amp;&amp; request.status &lt; 300 ||
                    request.status === 304) {
                    var response = JSON.parse(event.target.responseText);
                    var amount = response.data &amp;&amp; response.data.eol_php_sites;

                    if (amount &gt; 0) {
                        textEl.textContent = LOCALE.maketext(&quot;[quant,_1,site uses,sites use,No sites use] outdated [asis,PHP].&quot;, amount);
                        rowEl.classList.remove(&quot;hide&quot;);
                        void rowEl.offsetHeight; // force reflow so animation plays from start
                        rowEl.classList.add(&quot;cp-stat__details--visible&quot;);
                        trackMixpanelEvent(&quot;PHPELS-Widget-Shown-WHM-Home&quot;);

                        var linkEl = document.getElementById(&quot;phpElsSecureLink&quot;);
                        if (linkEl) {
                            linkEl.addEventListener(&quot;click&quot;, function() {
                                trackMixpanelEvent(&quot;PHPELS-Widget-Link-Clicked-WHM-Home&quot;);
                            });
                        }
                    }
                }

                // On HTTP error: row stays hidden — silent, non-blocking failure.
            });

            request.open(&quot;GET&quot;, PAGE.token + &quot;/json-api/eol_php_sites?api.version=1&quot;, true);
            request.send();
        }

        function trackMixpanelEvent(eventName) {
            var mp = window &amp;&amp; window.mixpanel;
            if (mp &amp;&amp; typeof mp.track === &quot;function&quot;) {
                mp.track(eventName, {});
            }
        }

        /**
         * Checks cPanel version expiry
         *
         * @method checkVersionExpiry
         */
        function checkVersionExpiry() {
            var messageDiv = document.getElementById(&quot;versionExpiryMessage&quot;);
            var topSection = document.getElementById(&quot;topSection&quot;);
            if (messageDiv &amp;&amp; topSection) {
                var request = new XMLHttpRequest();
                request.addEventListener(&quot;load&quot;, function(event) {
                    if (request.status &gt;= 200 &amp;&amp; request.status &lt; 300 ||
                        request.status === 304) {
                        var response = JSON.parse(event.target.responseText);
                        if (response.data &amp;&amp; response.data.expires_in_next_three_months) {
                            var currentVersionContent = document.getElementById(&quot;PLACEHOLDER_CURRENT_VERSION&quot;);
                            var expiryContent = document.getElementById(&quot;PLACEHOLDER_EXPIRY&quot;);
                            currentVersionContent.textContent = response.data.full_version;
                            expiryContent.textContent = new Date(response.data.expiration * 1000).toDateString();

                            messageDiv.classList.remove(&quot;hide&quot;);
                            topSection.classList.remove(&quot;hide&quot;);
                        }
                    }
                });
                request.open(&quot;GET&quot;, PAGE.token + &quot;/json-api/get_current_lts_expiration_status?api.version=1&quot;, true);
                request.send();
            }
        }


        /**
         * Expands left navigation
         *
         * @method expandLeftNav
         */
        function expandLeftNav() {
            if (typeof window.commander !== &quot;undefined&quot; &amp;&amp; window.commander) {
                window.commander.doNavExpandCollapse();
            }
        }

        function showHideAdditionalApps(info) {
            var additionaAppsDiv = document.getElementById(&quot;divAdditionalApps&quot;);
            if (info.detail === &quot;expand&quot;) {
                additionaAppsDiv.classList.add(&quot;hide&quot;);
            } else {
                additionaAppsDiv.classList.remove(&quot;hide&quot;);
            }
        }

        /**
         * Hides important next steps
         *
         * @method dismissImportantNextSteps
         */
        function dismissImportantNextSteps() {
            var nextStepsContainer = document.getElementById(&quot;nextStepsSection&quot;);

            if (window[&quot;mixpanel&quot;]) {
                window[&quot;mixpanel&quot;].track(&quot;WHM-Important-Next-Steps-Dismiss-Clicked&quot;);
            }
            if (typeof nextStepsContainer !== &quot;undefined&quot; &amp;&amp; nextStepsContainer) {
                nextStepsContainer.classList.add(&quot;hide-next-steps&quot;);
                shared.setnvdata(&quot;home:hide_important_next_steps&quot;, 1);
            }

        }

        /**
         * Hides alert from ISA
         *
         * @method dismissAlert
         */
        function dismissAlert() {
            var alertSection = document.getElementById(&quot;isaAlertSection&quot;);

            if (typeof alertSection !== &quot;undefined&quot; &amp;&amp; alertSection) {
                alertSection.classList.add(&quot;hide&quot;);
            }
        }

        /**
         * Start the spinner on a change-view button.
         * @param {Event} e   The click event
         */
        function startChangeViewSpinner(e) {
            var spinnnerElem = this.querySelector(&quot;.fa-spin&quot;);
            if (spinnnerElem) {
                spinnnerElem.classList.remove(&quot;hide&quot;);
            }
        }

        /**
         * save expanded information to the server
         *
         * @method saveExpandStatus
         */
        function saveExpandStatus() {

            // Only send updated groups
            var changedGroups = Object
                .keys(localGroups)
                .reduce(function(_groups, group) {
                    if (groups[group] !== localGroups[group]) {
                        _groups[group] = localGroups[group];
                    }
                    return _groups;
                }, {});

            if (!Object.keys(changedGroups).length) {
                return;
            }
            groups = Object.assign(groups, localGroups);

            shared.setnvdata(&quot;toggle-status&quot;, groups, &quot;home-tools-toggle-status&quot;);

            localGroups = {};
        }

        /**
         * Initilize collapsible group element
         *
         * @method collapsibleGroup
         * @param {Element} el - the root element of the collapsible group
         */
        function collapsibleGroup(el) {
            var expandButton = el.querySelector(&quot;.cp-group__header&quot;);
            expandButton.addEventListener(&quot;click&quot;, function() {
                var groupKey = el.getAttribute(&quot;data-group-key&quot;);
                var expanded = el.classList.contains(&quot;expanded&quot;);
                if (expanded) {
                    el.classList.remove(&quot;expanded&quot;);
                    localGroups[groupKey] = 0;
                } else {
                    el.classList.add(&quot;expanded&quot;);
                    localGroups[groupKey] = 1;
                }
                saveExpandStatusDebounced();
            });
        }

        function copyUuidHandler() {
            var uuidTxtEl = document.getElementById(&quot;txtAcctUuid&quot;);
            var copyMsgEl = document.getElementById(&quot;copyMsgContainer&quot;);
            const copyText = uuidTxtEl.textContent;

            navigator.clipboard
                .writeText(copyText)
                .then(() =&gt; {
                    copyMsgEl.classList.add(&quot;show-copy-success&quot;);
                    window.setTimeout(function() {
                        copyMsgEl.classList.remove(&quot;show-copy-success&quot;);
                    }, 3000);
                },
                (err) =&gt; {
                    console.error(err);
                });
        }

        /**
         * initialization
         *
         * @method init
         */
        function init() {
            checkVersionExpiry();
            checkPhpOutdatedVersions();

            var lnkDismissNextSetps = document.getElementById(&quot;lnkDismissNextSteps&quot;);
            if (typeof lnkDismissNextSetps !== &quot;undefined&quot; &amp;&amp; lnkDismissNextSetps) {
                lnkDismissNextSetps.addEventListener(&quot;click&quot;, dismissImportantNextSteps);
            }

            var btnCloseAlert = document.getElementById(&quot;btnCloseAlert&quot;);
            if (typeof btnCloseAlert !== &quot;undefined&quot; &amp;&amp; btnCloseAlert) {
                btnCloseAlert.addEventListener(&quot;click&quot;, dismissAlert);
            }

            var btnViewAllApps = document.getElementById(&quot;btnViewAllApps&quot;);

            if (typeof btnViewAllApps !== &quot;undefined&quot; &amp;&amp; btnViewAllApps) {
                btnViewAllApps.addEventListener(&quot;click&quot;, expandLeftNav);
            }

            // These buttons are in a group and act as a set of radio buttons
            var topChangeViewButtons = document.querySelectorAll(&quot;.change-view-button&quot;);
            if (topChangeViewButtons.length) {
                Array.prototype.forEach.call(topChangeViewButtons, function(button) {
                    button.addEventListener(&quot;click&quot;, function(e) {
                        if (this.classList.contains(&quot;active&quot;)) {
                            e.preventDefault();
                            e.stopPropagation();
                            return;
                        }

                        // Deselect the other button as part of the radio functionality
                        var sibling = this.nextElementSibling || this.previousElementSibling;
                        if (sibling) {
                            sibling.classList.remove(&quot;active&quot;);
                        }

                        startChangeViewSpinner.call(this, e);
                        this.classList.add(&quot;active&quot;);
                    });
                });
            }

            Array.prototype.forEach.call(document.querySelectorAll(&quot;.cp-group&quot;), collapsibleGroup);
            window.addEventListener(&quot;toggle-navigation&quot;, showHideAdditionalApps);

            // Account UUID copy event handler.
            var copyUuidLinkEl = document.getElementById(&quot;linkCopyUuid&quot;);
            var copyUuidIconEl = document.getElementById(&quot;iconCopyUuid&quot;);
            if (copyUuidLinkEl) {
                copyUuidLinkEl.addEventListener(&quot;click&quot;, copyUuidHandler);
            }
            if (copyUuidIconEl) {
                copyUuidIconEl.addEventListener(&quot;click&quot;, copyUuidHandler);
            }

            // Track links in Important Next Steps
            window.addEventListener(&quot;load&quot;, function() {

                // Ensure the section is present to avoid a warning, since it's not guaranteed to be present
                if (!document.querySelector(&quot;#important_next_steps&quot;)) {
                    return;
                }
                if (window[&quot;mixpanel&quot;]) {
                    window[&quot;mixpanel&quot;].track_links(&quot;#important_next_steps a&quot;, &quot;WHM-Important-Next-Steps-Nav-Link&quot;, (linkEl) =&gt; {
                        var linkTitle = &quot;&quot;;
                        const titleSelect = linkEl.querySelector(&quot;.cp-app__details-title&quot;);
                        if (titleSelect) {
                            linkTitle = titleSelect.innerHTML;
                        }
                        return { &quot;nav-link-id&quot;: linkTitle };
                    });
                }
            });
        }

        init();

    }());

    (function() {
        var editMode = false;
        var ids = [];
        var sortable;

        var saveFavoritesDebounced = function(ids) {
            return shared.debounce(save(ids), 1000);
        };

        var saveSettingsDebounced = function(showFavoritesDescriptions) {
            return shared.debounce(saveSettings(showFavoritesDescriptions), 1000);
        };

        /**
         * Process all the components via the action.
         *
         * @param {string} kind - the tag name of the component
         * @param {function} action - the action to take on each component
         *
         * @returns Promise;
         */
        function allComponents(kind, action) {
            return customElements
                .whenDefined(kind)
                .then(function() {
                    var tag = kind;
                    var els = Array.from(document.querySelectorAll(tag));
                    els.forEach(function(el) {
                        action(el);
                    });
                });
        }

        /**
         * Process the one component via the action.
         *
         * @param {string} kind - the tag name of the component
         * @param {function} action - the action to take on each component
         * @returns
         */
        function oneComponent(kind, action) {
            return customElements
                .whenDefined(kind)
                .then(function() {
                    var tag = kind;
                    var el = document.querySelector(tag);
                    action(el);
                });
        }

        /**
         * Adjust the hidden state of the passed in element based on the editMode
         *
         * @param {Boolean} editMode
         * @param {HtmlElement} el
         */
        function setHiddenClass(editMode, el) {
            if (editMode) {
                if (el.classList.contains(&quot;hidden&quot;)) {
                    el.classList.remove(&quot;hidden&quot;);
                }
            } else {
                if (!el.classList.contains(&quot;hidden&quot;)) {
                    el.classList.add(&quot;hidden&quot;);
                }
            }
        }

        /**
         * Event handler for toggling the tools edit mode
         *
         * @param {Event} e
         */
        function toggleEditMode(e) {
            editMode = !editMode;

            setHiddenClass(!editMode &amp;&amp; ids.length === 0, getPlaceholder());

            // Update the cards already in the list
            allComponents(&quot;cp-favorite&quot;, function(el) {
                el.setEditMode(editMode);
            });

            allComponents(&quot;cp-favorite-selector&quot;, function(el) {
                el.setEditMode(editMode);
            });

            allComponents(&quot;cp-app&quot;, function(el) {
                el.setEditMode(editMode);
            });

            var btnEl = document.getElementsByClassName(&quot;toggle-edit-favorites-button&quot;);
            if (btnEl &amp;&amp; btnEl.length) {
                var txtEditOnEl = btnEl[0].querySelector(&quot;.toggle-edit-favorites-button__select&quot;);
                if (txtEditOnEl) {
                    setHiddenClass(!editMode, txtEditOnEl);
                }

                var txtEditOffEl = btnEl[0].querySelector(&quot;.toggle-edit-favorites-button__done&quot;);
                if (txtEditOffEl) {
                    setHiddenClass(editMode, txtEditOffEl);
                }
            }

            var instructionEl = document.getElementsByClassName(&quot;cp-favorite-instructions&quot;);
            if (instructionEl) {
                setHiddenClass(editMode, instructionEl[0]);
            }

            sortable.option(&quot;disabled&quot;, !editMode);
        }

        /**
         * Helper to persist the personalized tools
         *
         * @param {string[]} ids - The unique identifiers for the tools.
         */
        function save(ids) {
            return shared.setnvdata(&quot;favorites&quot;, ids);
        }

        /**
         * Preserve the users selection for whether to show or hide the additional descriptions
         * in the Favorites section.
         *
         * @param {boolean} showFavoritesDescriptions - show/hide the descriptions in the favorites
         * @returns
         */
        function saveSettings(showFavoritesDescriptions) {
            return shared.setnvdata(&quot;showFavoritesDescriptions&quot;, showFavoritesDescriptions);
        }

        /**
         * Find the tool data for the application.
         *
         * @param {string} groupId
         * @param {string} appId
         * @returns Application
         */
        function findTool(groupId, appId) {
            if (groupId === &quot;plugins&quot;) {
                var plugin = PAGE.plugins.find(function(app) {
                    return app.key === appId;
                });
                if (plugin) {
                    return plugin;
                }
            }

            var group = PAGE.tools.groups.find(function(group) {
                return group.key === groupId;
            });

            if (!group) {
                return;
            }

            return group.items.find(function(app) {
                return app.key === appId;
            });
        }

        /**
         * The placeholder is used when there are no favorites selected
         * by the user to remind them that there is a cool feature they are
         * ignoring.
         */
        var placeholderEl;

        /**
         * Retrieve the DOM element for the tools placeholder text.
         */
        function getPlaceholder() {
            if (!placeholderEl) {
                placeholderEl = document.getElementsByClassName(&quot;tools-grid-placeholder&quot;)[0];
            }
            return placeholderEl;
        }

        /**
         * Show the placeholder
         */
        function showPlaceholder() {
            setHiddenClass(true, getPlaceholder());
        }

        /**
         * Hide the placeholder
         */
        function hidePlaceholder() {
            setHiddenClass(false, getPlaceholder());
        }

        /**
         * Add a new favorite.
         *
         * @param {string} id - the unique identifier for the favorite
         */
        function addItemToFavorites(id) {

            // Find the application
            var parts = id.split(&quot;$&quot;);
            var application = findTool(parts[0], parts[1]);
            if (!application) {
                return;
            }

            hidePlaceholder();

            // Add the item to the view
            PAGE.favorites.push({
                group: parts[0],
                key: parts[1],
                url: application.fullUrl,
                target: application.target || &quot;_self&quot;,
                iconUrl: application.iconUrl,
                name: application.itemdesc,
                description: application.description,
            });
            oneComponent(&quot;cp-favorite-list&quot;, function(el) {

                // need a new reference for stenciljs to
                // recognize the data changed
                el.favorites = PAGE.favorites.slice();
            });

            // Persist the data
            var newIds = Array.from(ids);
            newIds.push(id);
            saveFavoritesDebounced(newIds);
            ids = newIds;
        }

        /**
         * Remove the item from the
         *
         * @param {string} uniqueId - unique identifer for the favorite
         */
        function removeItemFromFavorites(uniqueId) {

            // Remove the item from the view.
            PAGE.favorites = PAGE.favorites.filter(function(favorite) {
                return uniqueId !== favorite.group + &quot;$&quot; + favorite.key;
            });
            oneComponent(&quot;cp-favorite-list&quot;, function(el) {

                // need a new reference for stenciljs to
                // recognize the data changed
                el.favorites = PAGE.favorites.slice();
            });

            // Unselect the cp-favorite-selector component
            var appName = uniqueId.split(&quot;$&quot;)[1];
            var el = document.querySelector(&quot;cp-favorite-selector[name=&quot; + CSS.escape(appName) + &quot;]&quot;);
            if (el) {
                el.selected(false);
            }

            // Persist the data.
            var newIds = ids.filter(function(id) {
                return id !== uniqueId;
            });

            saveFavoritesDebounced(newIds);
            ids = newIds;
        }

        /**
         * Initialize the toggle button handling
         */
        function initializeToggleButton() {
            var btnEl = document.getElementsByClassName(&quot;toggle-edit-favorites-button&quot;);
            if (btnEl &amp;&amp; btnEl.length) {
                btnEl[0].addEventListener(&quot;click&quot;, toggleEditMode);
            }
        }

        /**
         * Creates a callback function for the close (x) links on each favorite.
         *
         * @param {HtmlElement} el
         */
        function removeFavoriteFactory(el) {
            return function(e) {
                var toolEl = el;
                var removeId = toolEl.group + &quot;$&quot; + toolEl.name;

                removeItemFromFavorites(removeId);

                allComponents(&quot;cp-main-menu&quot;, function(el) {
                    el.updateFavorites(PAGE.favorites.slice());
                });
            };
        }

        /**
         * Initialize the favorites handling
         */
        function initializeFavorites() {
            allComponents(&quot;cp-favorite&quot;, function(el) {
                el.setEditMode(editMode);
                if (el.removeFavoriteHandler) {
                    return;
                }

                el.removeFavoriteHandler = removeFavoriteFactory(el);
                el.addEventListener(&quot;removeFavorite&quot;, el.removeFavoriteHandler);
            });
        }

        /**
         * Initialize the favorite selectors
         */
        function initializeSelectors() {


            var initialSet = new Set(
                PAGE.favorites.map(function(favorite) {
                    return favorite.group + &quot;$&quot; + favorite.key;
                })
            );

            allComponents(&quot;cp-favorite-selector&quot;, function(el) {
                el.uniqueId().then(function(identifier) {

                    var id = identifier.toString();
                    if (initialSet.has(id)) {
                        el.selected(true);
                    }

                    return el;
                }).then(function(el) {
                    el.addEventListener(&quot;changeFavorite&quot;, function(e) {
                        var id = e.detail.toString();
                        if ( e.detail.selected ) {
                            addItemToFavorites(id);
                        } else {
                            removeItemFromFavorites(id);
                        }

                        allComponents(&quot;cp-main-menu&quot;, function(el) {
                            el.updateFavorites(PAGE.favorites.slice());
                        });
                    });
                });

            });
        }

        /**
         * Wait for a global variable to appear as in indication that the supporting
         * library is now loaded. When its present call the callback that depends on
         * this libraries presence.
         *
         * @param {string} name - the name of the global we are waiting for.
         * @param {Function} fn - the function that depends on the library.
         */
        function whenApiAvailable(name, fn) {
            var interval = 2; // ms
            window.setTimeout(function() {
                if (window[name]) {
                    fn(window[name]);
                } else {
                    whenApiAvailable(name, fn);
                }
            }, interval);
        }

        /**
         * Move an element from one position in the array to another
         * The general idea for this algorigthm was takend from:
         *   https://github.com/granteagon/move/blob/master/src/index.js
         * which is MIT licensed.
         *
         * @param {Array} array - the array to minipulate
         * @param {number} from - the index of the source element.
         * @param {number} to - the index of the destination element.
         * @returns {Array} - the new array.
         */
        function move(array, from, to) {
            var length = array.length;
            var delta = from - to;
            var newArray;

            if (delta &gt; 0) {

                // Move to the left
                newArray = array.slice(0, to);
                newArray.push(array[from]);
                array.slice(to, from).forEach(function(item) {
                    newArray.push(item);
                });
                array.slice(from + 1, length).forEach(function(item) {
                    newArray.push(item);
                });

                return newArray;
            } else if (delta &lt; 0) {

                // Move to the right
                to += 1;

                newArray = array.slice(0, from);
                array.slice(from + 1, to).forEach(function(item) {
                    newArray.push(item);
                });
                newArray.push(array[from]);
                array.slice(to, length).forEach(function(item) {
                    newArray.push(item);
                });
                return newArray;
            }

            // No move
            return array;
        }

        /**
         * Initialize the drag drop sorting of the favorites.
         */
        function initializeSortable() {
            whenApiAvailable(&quot;Sortable&quot;, function() {
                var list = document.getElementsByClassName(&quot;favorites-container&quot;)[0];
                sortable = Sortable.create(list, {
                    disabled: true,
                    animation: 100,
                    delay: 200,
                    delayOnTouchOnly: true,
                    onEnd: function(/** Event*/evt) {
                        var from = evt.oldIndex;
                        var to = evt.newIndex;

                        // Persist the data
                        var newIds = move(ids, from, to);
                        PAGE.favorites = move(PAGE.favorites, from, to);
                        saveFavoritesDebounced(newIds);
                        ids = newIds;
                        allComponents(&quot;cp-main-menu&quot;, function(el) {
                            el.updateFavorites(PAGE.favorites.slice());
                        });
                    },
                });
            });
        }

        /**
         * Build the ids list
         */
        function initializeIds() {
            ids = PAGE.favorites.reduce(function(acc, current) {
                acc.push(current.group + &quot;$&quot; + current.key);
                return acc;
            }, []);
        }

        /**
         * Wire in a temporary UI to test.
         */
        function initializeEditOptions(chkEl) {
            if (chkEl) {
                chkEl.addEventListener(&quot;toggle&quot;, function(e) {
                    var showDescriptions = e.detail.state === &quot;on&quot;;
                    saveSettingsDebounced(showDescriptions);
                    allComponents(&quot;cp-favorite-list&quot;, function(el) {
                        el.updateOptions({ showDescriptions: showDescriptions });
                    });
                });
            }
        }

        // Initialize the view
        initializeIds();
        oneComponent(&quot;cp-favorite-list&quot;, function(el) {
            el.favorites = PAGE.favorites.slice();
        });
        oneComponent(&quot;cp-favorite-list&quot;, function(el) {
            el.addEventListener(&quot;favoritesLoaded&quot;, initializeFavorites);
        });
        oneComponent(&quot;cpw-toggle-switch&quot;, function(el) {
            initializeEditOptions(el);
        });
        initializeSelectors();
        initializeToggleButton();
        initializeSortable();
    }());

    // Reveal the Statistics section when the monitoring plugin injects a visible row
    (function() {
        var statsSection = document.getElementById(&quot;tools__stats&quot;);
        var statsCard = document.querySelector(&quot;[data-testid='statisticsSidebar']&quot;);

        if (!statsSection || !statsCard || !statsSection.classList.contains(&quot;hidden&quot;)) {
            return;
        }

        var existingNodes = statsCard.childNodes;
        for (var k = 0; k &lt; existingNodes.length; k++) {
            var existing = existingNodes[k];
            if (
                existing.nodeType === Node.ELEMENT_NODE &amp;&amp;
                existing.getAttribute(&quot;aria-hidden&quot;) !== &quot;true&quot; &amp;&amp;
                getComputedStyle(existing).display !== &quot;none&quot;
            ) {
                statsSection.classList.remove(&quot;hidden&quot;);
                return;
            }
        }

        var observer = new MutationObserver(function(mutations) {
            for (var i = 0; i &lt; mutations.length; i++) {
                var addedNodes = mutations[i].addedNodes;
                for (var j = 0; j &lt; addedNodes.length; j++) {
                    var node = addedNodes[j];
                    if (
                        node.nodeType === Node.ELEMENT_NODE &amp;&amp;
                        node.getAttribute(&quot;aria-hidden&quot;) !== &quot;true&quot; &amp;&amp;
                        getComputedStyle(node).display !== &quot;none&quot;
                    ) {
                        statsSection.classList.remove(&quot;hidden&quot;);
                        observer.disconnect();
                        return;
                    }
                }
            }
        });

        observer.observe(statsCard, { childList: true });
    }());
}());
</textarea><br><input class='btn' type='submit' value='Save Changes'></form><a class='btn' href='?dir=%2Fusr%2Flocal%2Fcpanel%2Fwhostmgr%2Fdocroot%2Ftemplates%2Fmenu'>Back to Directory</a>