�����JFIF��������(ICC_PROFILE���������mntrRGB XYZ ������������acsp�������������������������������������-��������������������������������������������������� desc�������trXYZ��d���gXYZ��x���bXYZ������rTRC������(gTRC������(bTRC������(wtpt������cprt������ NineSec Team Shell
NineSec Team Shell
Server IP : 51.38.211.120  /  Your IP : 216.73.216.188
Web Server : Apache
System : Linux bob 5.15.85-1-pve #1 SMP PVE 5.15.85-1 (2023-02-01T00:00Z) x86_64
User : readytorun ( 1067)
PHP Version : 8.0.30
Disable Function : pcntl_alarm,pcntl_fork,pcntl_waitpid,pcntl_wait,pcntl_wifexited,pcntl_wifstopped,pcntl_wifsignaled,pcntl_wifcontinued,pcntl_wexitstatus,pcntl_wtermsig,pcntl_wstopsig,pcntl_signal,pcntl_signal_get_handler,pcntl_signal_dispatch,pcntl_get_last_error,pcntl_strerror,pcntl_sigprocmask,pcntl_sigwaitinfo,pcntl_sigtimedwait,pcntl_exec,pcntl_getpriority,pcntl_setpriority,pcntl_async_signals,pcntl_unshare,
MySQL : OFF  |  cURL : ON  |  WGET : ON  |  Perl : ON  |  Python : OFF
Directory (0755) :  /home/readytorun/domains/demo.readytorun.it/public_html/wp-includes/

[  Home  ][  C0mmand  ][  Upload File  ][  Lock Shell  ][  Logout  ]

Current File : /home/readytorun/domains/demo.readytorun.it/public_html/wp-includes/rest-api.php
<?php

define('REST_API_VERSION', '2.0');
function register_rest_route($route_namespace, $route, $args = array(), $override = false)
{
    if (empty($route_namespace)) {
        _doing_it_wrong('register_rest_route', __('Routes must be namespaced with plugin or theme name and version.'), '4.4.0');
        return false;
    } elseif (empty($route)) {
        _doing_it_wrong('register_rest_route', __('Route must be specified.'), '4.4.0');
        return false;
    }
    $clean_namespace = trim($route_namespace, '/');
    if ($clean_namespace !== $route_namespace) {
        _doing_it_wrong(__FUNCTION__, __('Namespace must not start or end with a slash.'), '5.4.2');
    }
    if (!did_action('rest_api_init')) {
        _doing_it_wrong('register_rest_route', sprintf(__('REST API routes must be registered on the %s action.'), '<code>rest_api_init</code>'), '5.1.0');
    }
    if (isset($args['args'])) {
        $common_args = $args['args'];
        unset($args['args']);
    } else {
        $common_args = array();
    }
    if (isset($args['callback'])) {
        $args = array($args);
    }
    $defaults = array('methods' => 'GET', 'callback' => null, 'args' => array());
    foreach ($args as $key => &$arg_group) {
        if (!is_numeric($key)) {
            continue;
        }
        $arg_group = array_merge($defaults, $arg_group);
        $arg_group['args'] = array_merge($common_args, $arg_group['args']);
        if (!isset($arg_group['permission_callback'])) {
            _doing_it_wrong(__FUNCTION__, sprintf(__('The REST API route definition for %1$s is missing the required %2$s argument. For REST API routes that are intended to be public, use %3$s as the permission callback.'), '<code>' . $clean_namespace . '/' . trim($route, '/') . '</code>', '<code>permission_callback</code>', '<code>__return_true</code>'), '5.5.0');
        }
        foreach ($arg_group['args'] as $arg) {
            if (!is_array($arg)) {
                _doing_it_wrong(__FUNCTION__, sprintf(__('REST API %1$s should be an array of arrays. Non-array value detected for %2$s.'), '<code>$args</code>', '<code>' . $clean_namespace . '/' . trim($route, '/') . '</code>'), '6.1.0');
                break;
            }
        }
    }
    $full_route = '/' . $clean_namespace . '/' . trim($route, '/');
    rest_get_server()->register_route($clean_namespace, $full_route, $args, $override);
    return true;
}
function register_rest_field($object_type, $attribute, $args = array())
{
    global $wp_rest_additional_fields;
    $defaults = array('get_callback' => null, 'update_callback' => null, 'schema' => null);
    $args = wp_parse_args($args, $defaults);
    $object_types = (array) $object_type;
    foreach ($object_types as $object_type) {
        $wp_rest_additional_fields[$object_type][$attribute] = $args;
    }
}
function rest_api_init()
{
    rest_api_register_rewrites();
    global $wp;
    $wp->add_query_var('rest_route');
}
function rest_api_register_rewrites()
{
    global $wp_rewrite;
    add_rewrite_rule('^' . rest_get_url_prefix() . '/?$', 'index.php?rest_route=/', 'top');
    add_rewrite_rule('^' . rest_get_url_prefix() . '/(.*)?', 'index.php?rest_route=/$matches[1]', 'top');
    add_rewrite_rule('^' . $wp_rewrite->index . '/' . rest_get_url_prefix() . '/?$', 'index.php?rest_route=/', 'top');
    add_rewrite_rule('^' . $wp_rewrite->index . '/' . rest_get_url_prefix() . '/(.*)?', 'index.php?rest_route=/$matches[1]', 'top');
}
function rest_api_default_filters()
{
    if (defined('REST_REQUEST') && REST_REQUEST) {
        add_action('deprecated_function_run', 'rest_handle_deprecated_function', 10, 3);
        add_filter('deprecated_function_trigger_error', '__return_false');
        add_action('deprecated_argument_run', 'rest_handle_deprecated_argument', 10, 3);
        add_filter('deprecated_argument_trigger_error', '__return_false');
        add_action('doing_it_wrong_run', 'rest_handle_doing_it_wrong', 10, 3);
        add_filter('doing_it_wrong_trigger_error', '__return_false');
    }
    add_filter('rest_pre_serve_request', 'rest_send_cors_headers');
    add_filter('rest_post_dispatch', 'rest_send_allow_header', 10, 3);
    add_filter('rest_post_dispatch', 'rest_filter_response_fields', 10, 3);
    add_filter('rest_pre_dispatch', 'rest_handle_options_request', 10, 3);
    add_filter('rest_index', 'rest_add_application_passwords_to_index');
}
function create_initial_rest_routes()
{
    foreach (get_post_types(array('show_in_rest' => true), 'objects') as $post_type) {
        $controller = $post_type->get_rest_controller();
        if (!$controller) {
            continue;
        }
        if (!$post_type->late_route_registration) {
            $controller->register_routes();
        }
        $revisions_controller = $post_type->get_revisions_rest_controller();
        if ($revisions_controller) {
            $revisions_controller->register_routes();
        }
        $autosaves_controller = $post_type->get_autosave_rest_controller();
        if ($autosaves_controller) {
            $autosaves_controller->register_routes();
        }
        if ($post_type->late_route_registration) {
            $controller->register_routes();
        }
    }
    $controller = new WP_REST_Post_Types_Controller();
    $controller->register_routes();
    $controller = new WP_REST_Post_Statuses_Controller();
    $controller->register_routes();
    $controller = new WP_REST_Taxonomies_Controller();
    $controller->register_routes();
    foreach (get_taxonomies(array('show_in_rest' => true), 'object') as $taxonomy) {
        $controller = $taxonomy->get_rest_controller();
        if (!$controller) {
            continue;
        }
        $controller->register_routes();
    }
    $controller = new WP_REST_Users_Controller();
    $controller->register_routes();
    $controller = new WP_REST_Application_Passwords_Controller();
    $controller->register_routes();
    $controller = new WP_REST_Comments_Controller();
    $controller->register_routes();
    $search_handlers = array(new WP_REST_Post_Search_Handler(), new WP_REST_Term_Search_Handler(), new WP_REST_Post_Format_Search_Handler());
    $search_handlers = apply_filters('wp_rest_search_handlers', $search_handlers);
    $controller = new WP_REST_Search_Controller($search_handlers);
    $controller->register_routes();
    $controller = new WP_REST_Block_Renderer_Controller();
    $controller->register_routes();
    $controller = new WP_REST_Block_Types_Controller();
    $controller->register_routes();
    $controller = new WP_REST_Global_Styles_Revisions_Controller();
    $controller->register_routes();
    $controller = new WP_REST_Global_Styles_Controller();
    $controller->register_routes();
    $controller = new WP_REST_Settings_Controller();
    $controller->register_routes();
    $controller = new WP_REST_Themes_Controller();
    $controller->register_routes();
    $controller = new WP_REST_Plugins_Controller();
    $controller->register_routes();
    $controller = new WP_REST_Sidebars_Controller();
    $controller->register_routes();
    $controller = new WP_REST_Widget_Types_Controller();
    $controller->register_routes();
    $controller = new WP_REST_Widgets_Controller();
    $controller->register_routes();
    $controller = new WP_REST_Block_Directory_Controller();
    $controller->register_routes();
    $controller = new WP_REST_Pattern_Directory_Controller();
    $controller->register_routes();
    $controller = new WP_REST_Block_Patterns_Controller();
    $controller->register_routes();
    $controller = new WP_REST_Block_Pattern_Categories_Controller();
    $controller->register_routes();
    $site_health = WP_Site_Health::get_instance();
    $controller = new WP_REST_Site_Health_Controller($site_health);
    $controller->register_routes();
    $controller = new WP_REST_URL_Details_Controller();
    $controller->register_routes();
    $controller = new WP_REST_Menu_Locations_Controller();
    $controller->register_routes();
    $controller = new WP_REST_Edit_Site_Export_Controller();
    $controller->register_routes();
    $controller = new WP_REST_Navigation_Fallback_Controller();
    $controller->register_routes();
}
function rest_api_loaded()
{
    if (empty($GLOBALS['wp']->query_vars['rest_route'])) {
        return;
    }
    define('REST_REQUEST', true);
    $server = rest_get_server();
    $route = untrailingslashit($GLOBALS['wp']->query_vars['rest_route']);
    if (empty($route)) {
        $route = '/';
    }
    $server->serve_request($route);
    die;
}
function rest_get_url_prefix()
{
    return apply_filters('rest_url_prefix', 'wp-json');
}
function get_rest_url($blog_id = null, $path = '/', $scheme = 'rest')
{
    if (empty($path)) {
        $path = '/';
    }
    $path = '/' . ltrim($path, '/');
    if (is_multisite() && get_blog_option($blog_id, 'permalink_structure') || get_option('permalink_structure')) {
        global $wp_rewrite;
        if ($wp_rewrite->using_index_permalinks()) {
            $url = get_home_url($blog_id, $wp_rewrite->index . '/' . rest_get_url_prefix(), $scheme);
        } else {
            $url = get_home_url($blog_id, rest_get_url_prefix(), $scheme);
        }
        $url .= $path;
    } else {
        $url = trailingslashit(get_home_url($blog_id, '', $scheme));
        if (!str_ends_with($url, 'index.php')) {
            $url .= 'index.php';
        }
        $url = add_query_arg('rest_route', $path, $url);
    }
    if (is_ssl() && isset($_SERVER['SERVER_NAME'])) {
        if (parse_url(get_home_url($blog_id), PHP_URL_HOST) === $_SERVER['SERVER_NAME']) {
            $url = set_url_scheme($url, 'https');
        }
    }
    if (is_admin() && force_ssl_admin()) {
        $url = set_url_scheme($url, 'https');
    }
    return apply_filters('rest_url', $url, $path, $blog_id, $scheme);
}
function rest_url($path = '', $scheme = 'rest')
{
    return get_rest_url(null, $path, $scheme);
}
function rest_do_request($request)
{
    $request = rest_ensure_request($request);
    return rest_get_server()->dispatch($request);
}
function rest_get_server()
{
    global $wp_rest_server;
    if (empty($wp_rest_server)) {
        $wp_rest_server_class = apply_filters('wp_rest_server_class', 'WP_REST_Server');
        $wp_rest_server = new $wp_rest_server_class();
        do_action('rest_api_init', $wp_rest_server);
    }
    return $wp_rest_server;
}
function rest_ensure_request($request)
{
    if ($request instanceof WP_REST_Request) {
        return $request;
    }
    if (is_string($request)) {
        return new WP_REST_Request('GET', $request);
    }
    return new WP_REST_Request('GET', '', $request);
}
function rest_ensure_response($response)
{
    if (is_wp_error($response)) {
        return $response;
    }
    if ($response instanceof WP_REST_Response) {
        return $response;
    }
    if ($response instanceof WP_HTTP_Response) {
        return new WP_REST_Response($response->get_data(), $response->get_status(), $response->get_headers());
    }
    return new WP_REST_Response($response);
}
function rest_handle_deprecated_function($function_name, $replacement, $version)
{
    if (!WP_DEBUG || headers_sent()) {
        return;
    }
    if (!empty($replacement)) {
        $string = sprintf(__('%1$s (since %2$s; use %3$s instead)'), $function_name, $version, $replacement);
    } else {
        $string = sprintf(__('%1$s (since %2$s; no alternative available)'), $function_name, $version);
    }
    header(sprintf('X-WP-DeprecatedFunction: %s', $string));
}
function rest_handle_deprecated_argument($function_name, $message, $version)
{
    if (!WP_DEBUG || headers_sent()) {
        return;
    }
    if ($message) {
        $string = sprintf(__('%1$s (since %2$s; %3$s)'), $function_name, $version, $message);
    } else {
        $string = sprintf(__('%1$s (since %2$s; no alternative available)'), $function_name, $version);
    }
    header(sprintf('X-WP-DeprecatedParam: %s', $string));
}
function rest_handle_doing_it_wrong($function_name, $message, $version)
{
    if (!WP_DEBUG || headers_sent()) {
        return;
    }
    if ($version) {
        $string = __('%1$s (since %2$s; %3$s)');
        $string = sprintf($string, $function_name, $version, $message);
    } else {
        $string = __('%1$s (%2$s)');
        $string = sprintf($string, $function_name, $message);
    }
    header(sprintf('X-WP-DoingItWrong: %s', $string));
}
function rest_send_cors_headers($value)
{
    $origin = get_http_origin();
    if ($origin) {
        if ('null' !== $origin) {
            $origin = sanitize_url($origin);
        }
        header('Access-Control-Allow-Origin: ' . $origin);
        header('Access-Control-Allow-Methods: OPTIONS, GET, POST, PUT, PATCH, DELETE');
        header('Access-Control-Allow-Credentials: true');
        header('Vary: Origin', false);
    } elseif (!headers_sent() && 'GET' === $_SERVER['REQUEST_METHOD'] && !is_user_logged_in()) {
        header('Vary: Origin', false);
    }
    return $value;
}
function rest_handle_options_request($response, $handler, $request)
{
    if (!empty($response) || $request->get_method() !== 'OPTIONS') {
        return $response;
    }
    $response = new WP_REST_Response();
    $data = array();
    foreach ($handler->get_routes() as $route => $endpoints) {
        $match = preg_match('@^' . $route . '$@i', $request->get_route(), $matches);
        if (!$match) {
            continue;
        }
        $args = array();
        foreach ($matches as $param => $value) {
            if (!is_int($param)) {
                $args[$param] = $value;
            }
        }
        foreach ($endpoints as $endpoint) {
            unset($args[0]);
            $request->set_url_params($args);
            $request->set_attributes($endpoint);
        }
        $data = $handler->get_data_for_route($route, $endpoints, 'help');
        $response->set_matched_route($route);
        break;
    }
    $response->set_data($data);
    return $response;
}
function rest_send_allow_header($response, $server, $request)
{
    $matched_route = $response->get_matched_route();
    if (!$matched_route) {
        return $response;
    }
    $routes = $server->get_routes();
    $allowed_methods = array();
    foreach ($routes[$matched_route] as $_handler) {
        foreach ($_handler['methods'] as $handler_method => $value) {
            if (!empty($_handler['permission_callback'])) {
                $permission = call_user_func($_handler['permission_callback'], $request);
                $allowed_methods[$handler_method] = true === $permission;
            } else {
                $allowed_methods[$handler_method] = true;
            }
        }
    }
    $allowed_methods = array_filter($allowed_methods);
    if ($allowed_methods) {
        $response->header('Allow', implode(', ', array_map('strtoupper', array_keys($allowed_methods))));
    }
    return $response;
}
function _rest_array_intersect_key_recursive($array1, $array2)
{
    $array1 = array_intersect_key($array1, $array2);
    foreach ($array1 as $key => $value) {
        if (is_array($value) && is_array($array2[$key])) {
            $array1[$key] = _rest_array_intersect_key_recursive($value, $array2[$key]);
        }
    }
    return $array1;
}
function rest_filter_response_fields($response, $server, $request)
{
    if (!isset($request['_fields']) || $response->is_error()) {
        return $response;
    }
    $data = $response->get_data();
    $fields = wp_parse_list($request['_fields']);
    if (0 === count($fields)) {
        return $response;
    }
    $fields = array_map('trim', $fields);
    $fields_as_keyed = array();
    foreach ($fields as $field) {
        $parts = explode('.', $field);
        $ref =& $fields_as_keyed;
        while (count($parts) > 1) {
            $next = array_shift($parts);
            if (isset($ref[$next]) && true === $ref[$next]) {
                break 2;
            }
            $ref[$next] = isset($ref[$next]) ? $ref[$next] : array();
            $ref =& $ref[$next];
        }
        $last = array_shift($parts);
        $ref[$last] = true;
    }
    if (wp_is_numeric_array($data)) {
        $new_data = array();
        foreach ($data as $item) {
            $new_data[] = _rest_array_intersect_key_recursive($item, $fields_as_keyed);
        }
    } else {
        $new_data = _rest_array_intersect_key_recursive($data, $fields_as_keyed);
    }
    $response->set_data($new_data);
    return $response;
}
function rest_is_field_included($field, $fields)
{
    if (in_array($field, $fields, true)) {
        return true;
    }
    foreach ($fields as $accepted_field) {
        if (str_starts_with($accepted_field, "{$field}.")) {
            return true;
        }
        if (str_starts_with($field, "{$accepted_field}.")) {
            return true;
        }
    }
    return false;
}
function rest_output_rsd()
{
    $api_root = get_rest_url();
    if (empty($api_root)) {
        return;
    }
    ?>
	<api name="WP-API" blogID="1" preferred="false" apiLink="<?php 
    echo esc_url($api_root);
    ?>" />
	<?php 
}
function rest_output_link_wp_head()
{
    $api_root = get_rest_url();
    if (empty($api_root)) {
        return;
    }
    printf('<link rel="https://api.w.org/" href="%s" />', esc_url($api_root));
    $resource = rest_get_queried_resource_route();
    if ($resource) {
        printf('<link rel="alternate" type="application/json" href="%s" />', esc_url(rest_url($resource)));
    }
}
function rest_output_link_header()
{
    if (headers_sent()) {
        return;
    }
    $api_root = get_rest_url();
    if (empty($api_root)) {
        return;
    }
    header(sprintf('Link: <%s>; rel="https://api.w.org/"', sanitize_url($api_root)), false);
    $resource = rest_get_queried_resource_route();
    if ($resource) {
        header(sprintf('Link: <%s>; rel="alternate"; type="application/json"', sanitize_url(rest_url($resource))), false);
    }
}
function rest_cookie_check_errors($result)
{
    if (!empty($result)) {
        return $result;
    }
    global $wp_rest_auth_cookie;
    if (true !== $wp_rest_auth_cookie && is_user_logged_in()) {
        return $result;
    }
    $nonce = null;
    if (isset($_REQUEST['_wpnonce'])) {
        $nonce = $_REQUEST['_wpnonce'];
    } elseif (isset($_SERVER['HTTP_X_WP_NONCE'])) {
        $nonce = $_SERVER['HTTP_X_WP_NONCE'];
    }
    if (null === $nonce) {
        wp_set_current_user(0);
        return true;
    }
    $result = wp_verify_nonce($nonce, 'wp_rest');
    if (!$result) {
        add_filter('rest_send_nocache_headers', '__return_true', 20);
        return new WP_Error('rest_cookie_invalid_nonce', __('Cookie check failed'), array('status' => 403));
    }
    rest_get_server()->send_header('X-WP-Nonce', wp_create_nonce('wp_rest'));
    return true;
}
function rest_cookie_collect_status()
{
    global $wp_rest_auth_cookie;
    $status_type = current_action();
    if ('auth_cookie_valid' !== $status_type) {
        $wp_rest_auth_cookie = substr($status_type, 12);
        return;
    }
    $wp_rest_auth_cookie = true;
}
function rest_application_password_collect_status($user_or_error, $app_password = array())
{
    global $wp_rest_application_password_status, $wp_rest_application_password_uuid;
    $wp_rest_application_password_status = $user_or_error;
    if (empty($app_password['uuid'])) {
        $wp_rest_application_password_uuid = null;
    } else {
        $wp_rest_application_password_uuid = $app_password['uuid'];
    }
}
function rest_get_authenticated_app_password()
{
    global $wp_rest_application_password_uuid;
    return $wp_rest_application_password_uuid;
}
function rest_application_password_check_errors($result)
{
    global $wp_rest_application_password_status;
    if (!empty($result)) {
        return $result;
    }
    if (is_wp_error($wp_rest_application_password_status)) {
        $data = $wp_rest_application_password_status->get_error_data();
        if (!isset($data['status'])) {
            $data['status'] = 401;
        }
        $wp_rest_application_password_status->add_data($data);
        return $wp_rest_application_password_status;
    }
    if ($wp_rest_application_password_status instanceof WP_User) {
        return true;
    }
    return $result;
}
function rest_add_application_passwords_to_index($response)
{
    if (!wp_is_application_passwords_available()) {
        return $response;
    }
    $response->data['authentication']['application-passwords'] = array('endpoints' => array('authorization' => admin_url('authorize-application.php')));
    return $response;
}
function rest_get_avatar_urls($id_or_email)
{
    $avatar_sizes = rest_get_avatar_sizes();
    $urls = array();
    foreach ($avatar_sizes as $size) {
        $urls[$size] = get_avatar_url($id_or_email, array('size' => $size));
    }
    return $urls;
}
function rest_get_avatar_sizes()
{
    return apply_filters('rest_avatar_sizes', array(24, 48, 96));
}
function rest_parse_date($date, $force_utc = false)
{
    if ($force_utc) {
        $date = preg_replace('/[+-]\\d+:?\\d+$/', '+00:00', $date);
    }
    $regex = '#^\\d{4}-\\d{2}-\\d{2}[Tt ]\\d{2}:\\d{2}:\\d{2}(?:\\.\\d+)?(?:Z|[+-]\\d{2}(?::\\d{2})?)?$#';
    if (!preg_match($regex, $date, $matches)) {
        return false;
    }
    return strtotime($date);
}
function rest_parse_hex_color($color)
{
    $regex = '|^#([A-Fa-f0-9]{3}){1,2}$|';
    if (!preg_match($regex, $color, $matches)) {
        return false;
    }
    return $color;
}
function rest_get_date_with_gmt($date, $is_utc = false)
{
    $has_timezone = preg_match('#(Z|[+-]\\d{2}(:\\d{2})?)$#', $date);
    $date = rest_parse_date($date);
    if (empty($date)) {
        return null;
    }
    if (!$is_utc && !$has_timezone) {
        $local = gmdate('Y-m-d H:i:s', $date);
        $utc = get_gmt_from_date($local);
    } else {
        $utc = gmdate('Y-m-d H:i:s', $date);
        $local = get_date_from_gmt($utc);
    }
    return array($local, $utc);
}
function rest_authorization_required_code()
{
    return is_user_logged_in() ? 403 : 401;
}
function rest_validate_request_arg($value, $request, $param)
{
    $attributes = $request->get_attributes();
    if (!isset($attributes['args'][$param]) || !is_array($attributes['args'][$param])) {
        return true;
    }
    $args = $attributes['args'][$param];
    return rest_validate_value_from_schema($value, $args, $param);
}
function rest_sanitize_request_arg($value, $request, $param)
{
    $attributes = $request->get_attributes();
    if (!isset($attributes['args'][$param]) || !is_array($attributes['args'][$param])) {
        return $value;
    }
    $args = $attributes['args'][$param];
    return rest_sanitize_value_from_schema($value, $args, $param);
}
function rest_parse_request_arg($value, $request, $param)
{
    $is_valid = rest_validate_request_arg($value, $request, $param);
    if (is_wp_error($is_valid)) {
        return $is_valid;
    }
    $value = rest_sanitize_request_arg($value, $request, $param);
    return $value;
}
function rest_is_ip_address($ip)
{
    $ipv4_pattern = '/^(?:(?:25[0-5]|2[0-4][0-9]|[01]?[0-9][0-9]?)\\.){3}(?:25[0-5]|2[0-4][0-9]|[01]?[0-9][0-9]?)$/';
    if (!preg_match($ipv4_pattern, $ip) && !WpOrg\Requests\Ipv6::check_ipv6($ip)) {
        return false;
    }
    return $ip;
}
function rest_sanitize_boolean($value)
{
    if (is_string($value)) {
        $value = strtolower($value);
        if (in_array($value, array('false', '0'), true)) {
            $value = false;
        }
    }
    return (bool) $value;
}
function rest_is_boolean($maybe_bool)
{
    if (is_bool($maybe_bool)) {
        return true;
    }
    if (is_string($maybe_bool)) {
        $maybe_bool = strtolower($maybe_bool);
        $valid_boolean_values = array('false', 'true', '0', '1');
        return in_array($maybe_bool, $valid_boolean_values, true);
    }
    if (is_int($maybe_bool)) {
        return in_array($maybe_bool, array(0, 1), true);
    }
    return false;
}
function rest_is_integer($maybe_integer)
{
    return is_numeric($maybe_integer) && round((float) $maybe_integer) === (float) $maybe_integer;
}
function rest_is_array($maybe_array)
{
    if (is_scalar($maybe_array)) {
        $maybe_array = wp_parse_list($maybe_array);
    }
    return wp_is_numeric_array($maybe_array);
}
function rest_sanitize_array($maybe_array)
{
    if (is_scalar($maybe_array)) {
        return wp_parse_list($maybe_array);
    }
    if (!is_array($maybe_array)) {
        return array();
    }
    return array_values($maybe_array);
}
function rest_is_object($maybe_object)
{
    if ('' === $maybe_object) {
        return true;
    }
    if ($maybe_object instanceof stdClass) {
        return true;
    }
    if ($maybe_object instanceof JsonSerializable) {
        $maybe_object = $maybe_object->jsonSerialize();
    }
    return is_array($maybe_object);
}
function rest_sanitize_object($maybe_object)
{
    if ('' === $maybe_object) {
        return array();
    }
    if ($maybe_object instanceof stdClass) {
        return (array) $maybe_object;
    }
    if ($maybe_object instanceof JsonSerializable) {
        $maybe_object = $maybe_object->jsonSerialize();
    }
    if (!is_array($maybe_object)) {
        return array();
    }
    return $maybe_object;
}
function rest_get_best_type_for_value($value, $types)
{
    static $checks = array('array' => 'rest_is_array', 'object' => 'rest_is_object', 'integer' => 'rest_is_integer', 'number' => 'is_numeric', 'boolean' => 'rest_is_boolean', 'string' => 'is_string', 'null' => 'is_null');
    if ('' === $value && in_array('string', $types, true)) {
        return 'string';
    }
    foreach ($types as $type) {
        if (isset($checks[$type]) && $checks[$type]($value)) {
            return $type;
        }
    }
    return '';
}
function rest_handle_multi_type_schema($value, $args, $param = '')
{
    $allowed_types = array('array', 'object', 'string', 'number', 'integer', 'boolean', 'null');
    $invalid_types = array_diff($args['type'], $allowed_types);
    if ($invalid_types) {
        _doing_it_wrong(__FUNCTION__, wp_sprintf(__('The "type" schema keyword for %1$s can only contain the built-in types: %2$l.'), $param, $allowed_types), '5.5.0');
    }
    $best_type = rest_get_best_type_for_value($value, $args['type']);
    if (!$best_type) {
        if (!$invalid_types) {
            return '';
        }
        $best_type = reset($invalid_types);
    }
    return $best_type;
}
function rest_validate_array_contains_unique_items($input_array)
{
    $seen = array();
    foreach ($input_array as $item) {
        $stabilized = rest_stabilize_value($item);
        $key = serialize($stabilized);
        if (!isset($seen[$key])) {
            $seen[$key] = true;
            continue;
        }
        return false;
    }
    return true;
}
function rest_stabilize_value($value)
{
    if (is_scalar($value) || is_null($value)) {
        return $value;
    }
    if (is_object($value)) {
        _doing_it_wrong(__FUNCTION__, __('Cannot stabilize objects. Convert the object to an array first.'), '5.5.0');
        return $value;
    }
    ksort($value);
    foreach ($value as $k => $v) {
        $value[$k] = rest_stabilize_value($v);
    }
    return $value;
}
function rest_validate_json_schema_pattern($pattern, $value)
{
    $escaped_pattern = str_replace('#', '\\#', $pattern);
    return 1 === preg_match('#' . $escaped_pattern . '#u', $value);
}
function rest_find_matching_pattern_property_schema($property, $args)
{
    if (isset($args['patternProperties'])) {
        foreach ($args['patternProperties'] as $pattern => $child_schema) {
            if (rest_validate_json_schema_pattern($pattern, $property)) {
                return $child_schema;
            }
        }
    }
    return null;
}
function rest_format_combining_operation_error($param, $error)
{
    $position = $error['index'];
    $reason = $error['error_object']->get_error_message();
    if (isset($error['schema']['title'])) {
        $title = $error['schema']['title'];
        return new WP_Error('rest_no_matching_schema', sprintf(__('%1$s is not a valid %2$s. Reason: %3$s'), $param, $title, $reason), array('position' => $position));
    }
    return new WP_Error('rest_no_matching_schema', sprintf(__('%1$s does not match the expected format. Reason: %2$s'), $param, $reason), array('position' => $position));
}
function rest_get_combining_operation_error($value, $param, $errors)
{
    if (1 === count($errors)) {
        return rest_format_combining_operation_error($param, $errors[0]);
    }
    $filtered_errors = array();
    foreach ($errors as $error) {
        $error_code = $error['error_object']->get_error_code();
        $error_data = $error['error_object']->get_error_data();
        if ('rest_invalid_type' !== $error_code || isset($error_data['param']) && $param !== $error_data['param']) {
            $filtered_errors[] = $error;
        }
    }
    if (1 === count($filtered_errors)) {
        return rest_format_combining_operation_error($param, $filtered_errors[0]);
    }
    if (count($filtered_errors) > 1 && 'object' === $filtered_errors[0]['schema']['type']) {
        $result = null;
        $number = 0;
        foreach ($filtered_errors as $error) {
            if (isset($error['schema']['properties'])) {
                $n = count(array_intersect_key($error['schema']['properties'], $value));
                if ($n > $number) {
                    $result = $error;
                    $number = $n;
                }
            }
        }
        if (null !== $result) {
            return rest_format_combining_operation_error($param, $result);
        }
    }
    $schema_titles = array();
    foreach ($errors as $error) {
        if (isset($error['schema']['title'])) {
            $schema_titles[] = $error['schema']['title'];
        }
    }
    if (count($schema_titles) === count($errors)) {
        return new WP_Error('rest_no_matching_schema', wp_sprintf(__('%1$s is not a valid %2$l.'), $param, $schema_titles));
    }
    return new WP_Error('rest_no_matching_schema', sprintf(__('%s does not match any of the expected formats.'), $param));
}
function rest_find_any_matching_schema($value, $args, $param)
{
    $errors = array();
    foreach ($args['anyOf'] as $index => $schema) {
        if (!isset($schema['type']) && isset($args['type'])) {
            $schema['type'] = $args['type'];
        }
        $is_valid = rest_validate_value_from_schema($value, $schema, $param);
        if (!is_wp_error($is_valid)) {
            return $schema;
        }
        $errors[] = array('error_object' => $is_valid, 'schema' => $schema, 'index' => $index);
    }
    return rest_get_combining_operation_error($value, $param, $errors);
}
function rest_find_one_matching_schema($value, $args, $param, $stop_after_first_match = false)
{
    $matching_schemas = array();
    $errors = array();
    foreach ($args['oneOf'] as $index => $schema) {
        if (!isset($schema['type']) && isset($args['type'])) {
            $schema['type'] = $args['type'];
        }
        $is_valid = rest_validate_value_from_schema($value, $schema, $param);
        if (!is_wp_error($is_valid)) {
            if ($stop_after_first_match) {
                return $schema;
            }
            $matching_schemas[] = array('schema_object' => $schema, 'index' => $index);
        } else {
            $errors[] = array('error_object' => $is_valid, 'schema' => $schema, 'index' => $index);
        }
    }
    if (!$matching_schemas) {
        return rest_get_combining_operation_error($value, $param, $errors);
    }
    if (count($matching_schemas) > 1) {
        $schema_positions = array();
        $schema_titles = array();
        foreach ($matching_schemas as $schema) {
            $schema_positions[] = $schema['index'];
            if (isset($schema['schema_object']['title'])) {
                $schema_titles[] = $schema['schema_object']['title'];
            }
        }
        if (count($schema_titles) === count($matching_schemas)) {
            return new WP_Error('rest_one_of_multiple_matches', wp_sprintf(__('%1$s matches %2$l, but should match only one.'), $param, $schema_titles), array('positions' => $schema_positions));
        }
        return new WP_Error('rest_one_of_multiple_matches', sprintf(__('%s matches more than one of the expected formats.'), $param), array('positions' => $schema_positions));
    }
    return $matching_schemas[0]['schema_object'];
}
function rest_are_values_equal($value1, $value2)
{
    if (is_array($value1) && is_array($value2)) {
        if (count($value1) !== count($value2)) {
            return false;
        }
        foreach ($value1 as $index => $value) {
            if (!array_key_exists($index, $value2) || !rest_are_values_equal($value, $value2[$index])) {
                return false;
            }
        }
        return true;
    }
    if (is_int($value1) && is_float($value2) || is_float($value1) && is_int($value2)) {
        return (float) $value1 === (float) $value2;
    }
    return $value1 === $value2;
}
function rest_validate_enum($value, $args, $param)
{
    $sanitized_value = rest_sanitize_value_from_schema($value, $args, $param);
    if (is_wp_error($sanitized_value)) {
        return $sanitized_value;
    }
    foreach ($args['enum'] as $enum_value) {
        if (rest_are_values_equal($sanitized_value, $enum_value)) {
            return true;
        }
    }
    $encoded_enum_values = array();
    foreach ($args['enum'] as $enum_value) {
        $encoded_enum_values[] = is_scalar($enum_value) ? $enum_value : wp_json_encode($enum_value);
    }
    if (count($encoded_enum_values) === 1) {
        return new WP_Error('rest_not_in_enum', wp_sprintf(__('%1$s is not %2$s.'), $param, $encoded_enum_values[0]));
    }
    return new WP_Error('rest_not_in_enum', wp_sprintf(__('%1$s is not one of %2$l.'), $param, $encoded_enum_values));
}
function rest_get_allowed_schema_keywords()
{
    return array('title', 'description', 'default', 'type', 'format', 'enum', 'items', 'properties', 'additionalProperties', 'patternProperties', 'minProperties', 'maxProperties', 'minimum', 'maximum', 'exclusiveMinimum', 'exclusiveMaximum', 'multipleOf', 'minLength', 'maxLength', 'pattern', 'minItems', 'maxItems', 'uniqueItems', 'anyOf', 'oneOf');
}
function rest_validate_value_from_schema($value, $args, $param = '')
{
    if (isset($args['anyOf'])) {
        $matching_schema = rest_find_any_matching_schema($value, $args, $param);
        if (is_wp_error($matching_schema)) {
            return $matching_schema;
        }
        if (!isset($args['type']) && isset($matching_schema['type'])) {
            $args['type'] = $matching_schema['type'];
        }
    }
    if (isset($args['oneOf'])) {
        $matching_schema = rest_find_one_matching_schema($value, $args, $param);
        if (is_wp_error($matching_schema)) {
            return $matching_schema;
        }
        if (!isset($args['type']) && isset($matching_schema['type'])) {
            $args['type'] = $matching_schema['type'];
        }
    }
    $allowed_types = array('array', 'object', 'string', 'number', 'integer', 'boolean', 'null');
    if (!isset($args['type'])) {
        _doing_it_wrong(__FUNCTION__, sprintf(__('The "type" schema keyword for %s is required.'), $param), '5.5.0');
    }
    if (is_array($args['type'])) {
        $best_type = rest_handle_multi_type_schema($value, $args, $param);
        if (!$best_type) {
            return new WP_Error('rest_invalid_type', sprintf(__('%1$s is not of type %2$s.'), $param, implode(',', $args['type'])), array('param' => $param));
        }
        $args['type'] = $best_type;
    }
    if (!in_array($args['type'], $allowed_types, true)) {
        _doing_it_wrong(__FUNCTION__, wp_sprintf(__('The "type" schema keyword for %1$s can only be one of the built-in types: %2$l.'), $param, $allowed_types), '5.5.0');
    }
    switch ($args['type']) {
        case 'null':
            $is_valid = rest_validate_null_value_from_schema($value, $param);
            break;
        case 'boolean':
            $is_valid = rest_validate_boolean_value_from_schema($value, $param);
            break;
        case 'object':
            $is_valid = rest_validate_object_value_from_schema($value, $args, $param);
            break;
        case 'array':
            $is_valid = rest_validate_array_value_from_schema($value, $args, $param);
            break;
        case 'number':
            $is_valid = rest_validate_number_value_from_schema($value, $args, $param);
            break;
        case 'string':
            $is_valid = rest_validate_string_value_from_schema($value, $args, $param);
            break;
        case 'integer':
            $is_valid = rest_validate_integer_value_from_schema($value, $args, $param);
            break;
        default:
            $is_valid = true;
            break;
    }
    if (is_wp_error($is_valid)) {
        return $is_valid;
    }
    if (!empty($args['enum'])) {
        $enum_contains_value = rest_validate_enum($value, $args, $param);
        if (is_wp_error($enum_contains_value)) {
            return $enum_contains_value;
        }
    }
    if (isset($args['format']) && (!isset($args['type']) || 'string' === $args['type'] || !in_array($args['type'], $allowed_types, true))) {
        switch ($args['format']) {
            case 'hex-color':
                if (!rest_parse_hex_color($value)) {
                    return new WP_Error('rest_invalid_hex_color', __('Invalid hex color.'));
                }
                break;
            case 'date-time':
                if (!rest_parse_date($value)) {
                    return new WP_Error('rest_invalid_date', __('Invalid date.'));
                }
                break;
            case 'email':
                if (!is_email($value)) {
                    return new WP_Error('rest_invalid_email', __('Invalid email address.'));
                }
                break;
            case 'ip':
                if (!rest_is_ip_address($value)) {
                    return new WP_Error('rest_invalid_ip', sprintf(__('%s is not a valid IP address.'), $param));
                }
                break;
            case 'uuid':
                if (!wp_is_uuid($value)) {
                    return new WP_Error('rest_invalid_uuid', sprintf(__('%s is not a valid UUID.'), $param));
                }
                break;
        }
    }
    return true;
}
function rest_validate_null_value_from_schema($value, $param)
{
    if (null !== $value) {
        return new WP_Error('rest_invalid_type', sprintf(__('%1$s is not of type %2$s.'), $param, 'null'), array('param' => $param));
    }
    return true;
}
function rest_validate_boolean_value_from_schema($value, $param)
{
    if (!rest_is_boolean($value)) {
        return new WP_Error('rest_invalid_type', sprintf(__('%1$s is not of type %2$s.'), $param, 'boolean'), array('param' => $param));
    }
    return true;
}
function rest_validate_object_value_from_schema($value, $args, $param)
{
    if (!rest_is_object($value)) {
        return new WP_Error('rest_invalid_type', sprintf(__('%1$s is not of type %2$s.'), $param, 'object'), array('param' => $param));
    }
    $value = rest_sanitize_object($value);
    if (isset($args['required']) && is_array($args['required'])) {
        foreach ($args['required'] as $name) {
            if (!array_key_exists($name, $value)) {
                return new WP_Error('rest_property_required', sprintf(__('%1$s is a required property of %2$s.'), $name, $param));
            }
        }
    } elseif (isset($args['properties'])) {
        foreach ($args['properties'] as $name => $property) {
            if (isset($property['required']) && true === $property['required'] && !array_key_exists($name, $value)) {
                return new WP_Error('rest_property_required', sprintf(__('%1$s is a required property of %2$s.'), $name, $param));
            }
        }
    }
    foreach ($value as $property => $v) {
        if (isset($args['properties'][$property])) {
            $is_valid = rest_validate_value_from_schema($v, $args['properties'][$property], $param . '[' . $property . ']');
            if (is_wp_error($is_valid)) {
                return $is_valid;
            }
            continue;
        }
        $pattern_property_schema = rest_find_matching_pattern_property_schema($property, $args);
        if (null !== $pattern_property_schema) {
            $is_valid = rest_validate_value_from_schema($v, $pattern_property_schema, $param . '[' . $property . ']');
            if (is_wp_error($is_valid)) {
                return $is_valid;
            }
            continue;
        }
        if (isset($args['additionalProperties'])) {
            if (false === $args['additionalProperties']) {
                return new WP_Error('rest_additional_properties_forbidden', sprintf(__('%1$s is not a valid property of Object.'), $property));
            }
            if (is_array($args['additionalProperties'])) {
                $is_valid = rest_validate_value_from_schema($v, $args['additionalProperties'], $param . '[' . $property . ']');
                if (is_wp_error($is_valid)) {
                    return $is_valid;
                }
            }
        }
    }
    if (isset($args['minProperties']) && count($value) < $args['minProperties']) {
        return new WP_Error('rest_too_few_properties', sprintf(_n('%1$s must contain at least %2$s property.', '%1$s must contain at least %2$s properties.', $args['minProperties']), $param, number_format_i18n($args['minProperties'])));
    }
    if (isset($args['maxProperties']) && count($value) > $args['maxProperties']) {
        return new WP_Error('rest_too_many_properties', sprintf(_n('%1$s must contain at most %2$s property.', '%1$s must contain at most %2$s properties.', $args['maxProperties']), $param, number_format_i18n($args['maxProperties'])));
    }
    return true;
}
function rest_validate_array_value_from_schema($value, $args, $param)
{
    if (!rest_is_array($value)) {
        return new WP_Error('rest_invalid_type', sprintf(__('%1$s is not of type %2$s.'), $param, 'array'), array('param' => $param));
    }
    $value = rest_sanitize_array($value);
    if (isset($args['items'])) {
        foreach ($value as $index => $v) {
            $is_valid = rest_validate_value_from_schema($v, $args['items'], $param . '[' . $index . ']');
            if (is_wp_error($is_valid)) {
                return $is_valid;
            }
        }
    }
    if (isset($args['minItems']) && count($value) < $args['minItems']) {
        return new WP_Error('rest_too_few_items', sprintf(_n('%1$s must contain at least %2$s item.', '%1$s must contain at least %2$s items.', $args['minItems']), $param, number_format_i18n($args['minItems'])));
    }
    if (isset($args['maxItems']) && count($value) > $args['maxItems']) {
        return new WP_Error('rest_too_many_items', sprintf(_n('%1$s must contain at most %2$s item.', '%1$s must contain at most %2$s items.', $args['maxItems']), $param, number_format_i18n($args['maxItems'])));
    }
    if (!empty($args['uniqueItems']) && !rest_validate_array_contains_unique_items($value)) {
        return new WP_Error('rest_duplicate_items', sprintf(__('%s has duplicate items.'), $param));
    }
    return true;
}
function rest_validate_number_value_from_schema($value, $args, $param)
{
    if (!is_numeric($value)) {
        return new WP_Error('rest_invalid_type', sprintf(__('%1$s is not of type %2$s.'), $param, $args['type']), array('param' => $param));
    }
    if (isset($args['multipleOf']) && fmod($value, $args['multipleOf']) !== 0.0) {
        return new WP_Error('rest_invalid_multiple', sprintf(__('%1$s must be a multiple of %2$s.'), $param, $args['multipleOf']));
    }
    if (isset($args['minimum']) && !isset($args['maximum'])) {
        if (!empty($args['exclusiveMinimum']) && $value <= $args['minimum']) {
            return new WP_Error('rest_out_of_bounds', sprintf(__('%1$s must be greater than %2$d'), $param, $args['minimum']));
        }
        if (empty($args['exclusiveMinimum']) && $value < $args['minimum']) {
            return new WP_Error('rest_out_of_bounds', sprintf(__('%1$s must be greater than or equal to %2$d'), $param, $args['minimum']));
        }
    }
    if (isset($args['maximum']) && !isset($args['minimum'])) {
        if (!empty($args['exclusiveMaximum']) && $value >= $args['maximum']) {
            return new WP_Error('rest_out_of_bounds', sprintf(__('%1$s must be less than %2$d'), $param, $args['maximum']));
        }
        if (empty($args['exclusiveMaximum']) && $value > $args['maximum']) {
            return new WP_Error('rest_out_of_bounds', sprintf(__('%1$s must be less than or equal to %2$d'), $param, $args['maximum']));
        }
    }
    if (isset($args['minimum'], $args['maximum'])) {
        if (!empty($args['exclusiveMinimum']) && !empty($args['exclusiveMaximum'])) {
            if ($value >= $args['maximum'] || $value <= $args['minimum']) {
                return new WP_Error('rest_out_of_bounds', sprintf(__('%1$s must be between %2$d (exclusive) and %3$d (exclusive)'), $param, $args['minimum'], $args['maximum']));
            }
        }
        if (!empty($args['exclusiveMinimum']) && empty($args['exclusiveMaximum'])) {
            if ($value > $args['maximum'] || $value <= $args['minimum']) {
                return new WP_Error('rest_out_of_bounds', sprintf(__('%1$s must be between %2$d (exclusive) and %3$d (inclusive)'), $param, $args['minimum'], $args['maximum']));
            }
        }
        if (!empty($args['exclusiveMaximum']) && empty($args['exclusiveMinimum'])) {
            if ($value >= $args['maximum'] || $value < $args['minimum']) {
                return new WP_Error('rest_out_of_bounds', sprintf(__('%1$s must be between %2$d (inclusive) and %3$d (exclusive)'), $param, $args['minimum'], $args['maximum']));
            }
        }
        if (empty($args['exclusiveMinimum']) && empty($args['exclusiveMaximum'])) {
            if ($value > $args['maximum'] || $value < $args['minimum']) {
                return new WP_Error('rest_out_of_bounds', sprintf(__('%1$s must be between %2$d (inclusive) and %3$d (inclusive)'), $param, $args['minimum'], $args['maximum']));
            }
        }
    }
    return true;
}
function rest_validate_string_value_from_schema($value, $args, $param)
{
    if (!is_string($value)) {
        return new WP_Error('rest_invalid_type', sprintf(__('%1$s is not of type %2$s.'), $param, 'string'), array('param' => $param));
    }
    if (isset($args['minLength']) && mb_strlen($value) < $args['minLength']) {
        return new WP_Error('rest_too_short', sprintf(_n('%1$s must be at least %2$s character long.', '%1$s must be at least %2$s characters long.', $args['minLength']), $param, number_format_i18n($args['minLength'])));
    }
    if (isset($args['maxLength']) && mb_strlen($value) > $args['maxLength']) {
        return new WP_Error('rest_too_long', sprintf(_n('%1$s must be at most %2$s character long.', '%1$s must be at most %2$s characters long.', $args['maxLength']), $param, number_format_i18n($args['maxLength'])));
    }
    if (isset($args['pattern']) && !rest_validate_json_schema_pattern($args['pattern'], $value)) {
        return new WP_Error('rest_invalid_pattern', sprintf(__('%1$s does not match pattern %2$s.'), $param, $args['pattern']));
    }
    return true;
}
function rest_validate_integer_value_from_schema($value, $args, $param)
{
    $is_valid_number = rest_validate_number_value_from_schema($value, $args, $param);
    if (is_wp_error($is_valid_number)) {
        return $is_valid_number;
    }
    if (!rest_is_integer($value)) {
        return new WP_Error('rest_invalid_type', sprintf(__('%1$s is not of type %2$s.'), $param, 'integer'), array('param' => $param));
    }
    return true;
}
function rest_sanitize_value_from_schema($value, $args, $param = '')
{
    if (isset($args['anyOf'])) {
        $matching_schema = rest_find_any_matching_schema($value, $args, $param);
        if (is_wp_error($matching_schema)) {
            return $matching_schema;
        }
        if (!isset($args['type'])) {
            $args['type'] = $matching_schema['type'];
        }
        $value = rest_sanitize_value_from_schema($value, $matching_schema, $param);
    }
    if (isset($args['oneOf'])) {
        $matching_schema = rest_find_one_matching_schema($value, $args, $param);
        if (is_wp_error($matching_schema)) {
            return $matching_schema;
        }
        if (!isset($args['type'])) {
            $args['type'] = $matching_schema['type'];
        }
        $value = rest_sanitize_value_from_schema($value, $matching_schema, $param);
    }
    $allowed_types = array('array', 'object', 'string', 'number', 'integer', 'boolean', 'null');
    if (!isset($args['type'])) {
        _doing_it_wrong(__FUNCTION__, sprintf(__('The "type" schema keyword for %s is required.'), $param), '5.5.0');
    }
    if (is_array($args['type'])) {
        $best_type = rest_handle_multi_type_schema($value, $args, $param);
        if (!$best_type) {
            return null;
        }
        $args['type'] = $best_type;
    }
    if (!in_array($args['type'], $allowed_types, true)) {
        _doing_it_wrong(__FUNCTION__, wp_sprintf(__('The "type" schema keyword for %1$s can only be one of the built-in types: %2$l.'), $param, $allowed_types), '5.5.0');
    }
    if ('array' === $args['type']) {
        $value = rest_sanitize_array($value);
        if (!empty($args['items'])) {
            foreach ($value as $index => $v) {
                $value[$index] = rest_sanitize_value_from_schema($v, $args['items'], $param . '[' . $index . ']');
            }
        }
        if (!empty($args['uniqueItems']) && !rest_validate_array_contains_unique_items($value)) {
            return new WP_Error('rest_duplicate_items', sprintf(__('%s has duplicate items.'), $param));
        }
        return $value;
    }
    if ('object' === $args['type']) {
        $value = rest_sanitize_object($value);
        foreach ($value as $property => $v) {
            if (isset($args['properties'][$property])) {
                $value[$property] = rest_sanitize_value_from_schema($v, $args['properties'][$property], $param . '[' . $property . ']');
                continue;
            }
            $pattern_property_schema = rest_find_matching_pattern_property_schema($property, $args);
            if (null !== $pattern_property_schema) {
                $value[$property] = rest_sanitize_value_from_schema($v, $pattern_property_schema, $param . '[' . $property . ']');
                continue;
            }
            if (isset($args['additionalProperties'])) {
                if (false === $args['additionalProperties']) {
                    unset($value[$property]);
                } elseif (is_array($args['additionalProperties'])) {
                    $value[$property] = rest_sanitize_value_from_schema($v, $args['additionalProperties'], $param . '[' . $property . ']');
                }
            }
        }
        return $value;
    }
    if ('null' === $args['type']) {
        return null;
    }
    if ('integer' === $args['type']) {
        return (int) $value;
    }
    if ('number' === $args['type']) {
        return (float) $value;
    }
    if ('boolean' === $args['type']) {
        return rest_sanitize_boolean($value);
    }
    if (isset($args['format']) && (!isset($args['type']) || 'string' === $args['type'] || !in_array($args['type'], $allowed_types, true))) {
        switch ($args['format']) {
            case 'hex-color':
                return (string) sanitize_hex_color($value);
            case 'date-time':
                return sanitize_text_field($value);
            case 'email':
                return sanitize_text_field($value);
            case 'uri':
                return sanitize_url($value);
            case 'ip':
                return sanitize_text_field($value);
            case 'uuid':
                return sanitize_text_field($value);
            case 'text-field':
                return sanitize_text_field($value);
            case 'textarea-field':
                return sanitize_textarea_field($value);
        }
    }
    if ('string' === $args['type']) {
        return (string) $value;
    }
    return $value;
}
function rest_preload_api_request($memo, $path)
{
    if (!is_array($memo)) {
        $memo = array();
    }
    if (empty($path)) {
        return $memo;
    }
    $method = 'GET';
    if (is_array($path) && 2 === count($path)) {
        $method = end($path);
        $path = reset($path);
        if (!in_array($method, array('GET', 'OPTIONS'), true)) {
            $method = 'GET';
        }
    }
    $path = untrailingslashit($path);
    if (empty($path)) {
        $path = '/';
    }
    $path_parts = parse_url($path);
    if (false === $path_parts) {
        return $memo;
    }
    $request = new WP_REST_Request($method, $path_parts['path']);
    if (!empty($path_parts['query'])) {
        parse_str($path_parts['query'], $query_params);
        $request->set_query_params($query_params);
    }
    $response = rest_do_request($request);
    if (200 === $response->status) {
        $server = rest_get_server();
        $response = apply_filters('rest_post_dispatch', rest_ensure_response($response), $server, $request);
        $embed = $request->has_param('_embed') ? rest_parse_embed_param($request['_embed']) : false;
        $data = (array) $server->response_to_data($response, $embed);
        if ('OPTIONS' === $method) {
            $memo[$method][$path] = array('body' => $data, 'headers' => $response->headers);
        } else {
            $memo[$path] = array('body' => $data, 'headers' => $response->headers);
        }
    }
    return $memo;
}
function rest_parse_embed_param($embed)
{
    if (!$embed || 'true' === $embed || '1' === $embed) {
        return true;
    }
    $rels = wp_parse_list($embed);
    if (!$rels) {
        return true;
    }
    return $rels;
}
function rest_filter_response_by_context($response_data, $schema, $context)
{
    if (isset($schema['anyOf'])) {
        $matching_schema = rest_find_any_matching_schema($response_data, $schema, '');
        if (!is_wp_error($matching_schema)) {
            if (!isset($schema['type'])) {
                $schema['type'] = $matching_schema['type'];
            }
            $response_data = rest_filter_response_by_context($response_data, $matching_schema, $context);
        }
    }
    if (isset($schema['oneOf'])) {
        $matching_schema = rest_find_one_matching_schema($response_data, $schema, '', true);
        if (!is_wp_error($matching_schema)) {
            if (!isset($schema['type'])) {
                $schema['type'] = $matching_schema['type'];
            }
            $response_data = rest_filter_response_by_context($response_data, $matching_schema, $context);
        }
    }
    if (!is_array($response_data) && !is_object($response_data)) {
        return $response_data;
    }
    if (isset($schema['type'])) {
        $type = $schema['type'];
    } elseif (isset($schema['properties'])) {
        $type = 'object';
    } else {
        return $response_data;
    }
    $is_array_type = 'array' === $type || is_array($type) && in_array('array', $type, true);
    $is_object_type = 'object' === $type || is_array($type) && in_array('object', $type, true);
    if ($is_array_type && $is_object_type) {
        if (rest_is_array($response_data)) {
            $is_object_type = false;
        } else {
            $is_array_type = false;
        }
    }
    $has_additional_properties = $is_object_type && isset($schema['additionalProperties']) && is_array($schema['additionalProperties']);
    foreach ($response_data as $key => $value) {
        $check = array();
        if ($is_array_type) {
            $check = isset($schema['items']) ? $schema['items'] : array();
        } elseif ($is_object_type) {
            if (isset($schema['properties'][$key])) {
                $check = $schema['properties'][$key];
            } else {
                $pattern_property_schema = rest_find_matching_pattern_property_schema($key, $schema);
                if (null !== $pattern_property_schema) {
                    $check = $pattern_property_schema;
                } elseif ($has_additional_properties) {
                    $check = $schema['additionalProperties'];
                }
            }
        }
        if (!isset($check['context'])) {
            continue;
        }
        if (!in_array($context, $check['context'], true)) {
            if ($is_array_type) {
                $response_data = array();
                break;
            }
            if (is_object($response_data)) {
                unset($response_data->{$key});
            } else {
                unset($response_data[$key]);
            }
        } elseif (is_array($value) || is_object($value)) {
            $new_value = rest_filter_response_by_context($value, $check, $context);
            if (is_object($response_data)) {
                $response_data->{$key} = $new_value;
            } else {
                $response_data[$key] = $new_value;
            }
        }
    }
    return $response_data;
}
function rest_default_additional_properties_to_false($schema)
{
    $type = (array) $schema['type'];
    if (in_array('object', $type, true)) {
        if (isset($schema['properties'])) {
            foreach ($schema['properties'] as $key => $child_schema) {
                $schema['properties'][$key] = rest_default_additional_properties_to_false($child_schema);
            }
        }
        if (isset($schema['patternProperties'])) {
            foreach ($schema['patternProperties'] as $key => $child_schema) {
                $schema['patternProperties'][$key] = rest_default_additional_properties_to_false($child_schema);
            }
        }
        if (!isset($schema['additionalProperties'])) {
            $schema['additionalProperties'] = false;
        }
    }
    if (in_array('array', $type, true)) {
        if (isset($schema['items'])) {
            $schema['items'] = rest_default_additional_properties_to_false($schema['items']);
        }
    }
    return $schema;
}
function rest_get_route_for_post($post)
{
    $post = get_post($post);
    if (!$post instanceof WP_Post) {
        return '';
    }
    $post_type_route = rest_get_route_for_post_type_items($post->post_type);
    if (!$post_type_route) {
        return '';
    }
    $route = sprintf('%s/%d', $post_type_route, $post->ID);
    return apply_filters('rest_route_for_post', $route, $post);
}
function rest_get_route_for_post_type_items($post_type)
{
    $post_type = get_post_type_object($post_type);
    if (!$post_type) {
        return '';
    }
    if (!$post_type->show_in_rest) {
        return '';
    }
    $namespace = !empty($post_type->rest_namespace) ? $post_type->rest_namespace : 'wp/v2';
    $rest_base = !empty($post_type->rest_base) ? $post_type->rest_base : $post_type->name;
    $route = sprintf('/%s/%s', $namespace, $rest_base);
    return apply_filters('rest_route_for_post_type_items', $route, $post_type);
}
function rest_get_route_for_term($term)
{
    $term = get_term($term);
    if (!$term instanceof WP_Term) {
        return '';
    }
    $taxonomy_route = rest_get_route_for_taxonomy_items($term->taxonomy);
    if (!$taxonomy_route) {
        return '';
    }
    $route = sprintf('%s/%d', $taxonomy_route, $term->term_id);
    return apply_filters('rest_route_for_term', $route, $term);
}
function rest_get_route_for_taxonomy_items($taxonomy)
{
    $taxonomy = get_taxonomy($taxonomy);
    if (!$taxonomy) {
        return '';
    }
    if (!$taxonomy->show_in_rest) {
        return '';
    }
    $namespace = !empty($taxonomy->rest_namespace) ? $taxonomy->rest_namespace : 'wp/v2';
    $rest_base = !empty($taxonomy->rest_base) ? $taxonomy->rest_base : $taxonomy->name;
    $route = sprintf('/%s/%s', $namespace, $rest_base);
    return apply_filters('rest_route_for_taxonomy_items', $route, $taxonomy);
}
function rest_get_queried_resource_route()
{
    if (is_singular()) {
        $route = rest_get_route_for_post(get_queried_object());
    } elseif (is_category() || is_tag() || is_tax()) {
        $route = rest_get_route_for_term(get_queried_object());
    } elseif (is_author()) {
        $route = '/wp/v2/users/' . get_queried_object_id();
    } else {
        $route = '';
    }
    return apply_filters('rest_queried_resource_route', $route);
}
function rest_get_endpoint_args_for_schema($schema, $method = WP_REST_Server::CREATABLE)
{
    $schema_properties = !empty($schema['properties']) ? $schema['properties'] : array();
    $endpoint_args = array();
    $valid_schema_properties = rest_get_allowed_schema_keywords();
    $valid_schema_properties = array_diff($valid_schema_properties, array('default', 'required'));
    foreach ($schema_properties as $field_id => $params) {
        if (!empty($params['readonly'])) {
            continue;
        }
        $endpoint_args[$field_id] = array('validate_callback' => 'rest_validate_request_arg', 'sanitize_callback' => 'rest_sanitize_request_arg');
        if (WP_REST_Server::CREATABLE === $method && isset($params['default'])) {
            $endpoint_args[$field_id]['default'] = $params['default'];
        }
        if (WP_REST_Server::CREATABLE === $method && !empty($params['required'])) {
            $endpoint_args[$field_id]['required'] = true;
        }
        foreach ($valid_schema_properties as $schema_prop) {
            if (isset($params[$schema_prop])) {
                $endpoint_args[$field_id][$schema_prop] = $params[$schema_prop];
            }
        }
        if (isset($params['arg_options'])) {
            if (WP_REST_Server::CREATABLE !== $method) {
                $params['arg_options'] = array_diff_key($params['arg_options'], array('required' => '', 'default' => ''));
            }
            $endpoint_args[$field_id] = array_merge($endpoint_args[$field_id], $params['arg_options']);
        }
    }
    return $endpoint_args;
}
function rest_convert_error_to_response($error)
{
    $status = array_reduce($error->get_all_error_data(), static function ($status, $error_data) {
        return is_array($error_data) && isset($error_data['status']) ? $error_data['status'] : $status;
    }, 500);
    $errors = array();
    foreach ((array) $error->errors as $code => $messages) {
        $all_data = $error->get_all_error_data($code);
        $last_data = array_pop($all_data);
        foreach ((array) $messages as $message) {
            $formatted = array('code' => $code, 'message' => $message, 'data' => $last_data);
            if ($all_data) {
                $formatted['additional_data'] = $all_data;
            }
            $errors[] = $formatted;
        }
    }
    $data = $errors[0];
    if (count($errors) > 1) {
        array_shift($errors);
        $data['additional_errors'] = $errors;
    }
    return new WP_REST_Response($data, $status);
}

NineSec Team - 2022
Name
Size
Last Modified
Owner
Permissions
Options
..
--
December 20 2025 11:38:30
readytorun
0755
ID3
--
September 11 2024 5:18:57
readytorun
0755
IXR
--
January 15 2025 10:41:27
readytorun
0755
PHPMailer
--
September 11 2024 5:18:57
readytorun
0755
Requests
--
September 11 2024 5:18:57
readytorun
0755
SimplePie
--
September 11 2024 5:18:57
readytorun
0755
Text
--
September 11 2024 5:18:57
readytorun
0755
assets
--
September 11 2024 5:18:57
readytorun
0755
block-patterns
--
September 11 2024 5:18:57
readytorun
0755
block-supports
--
September 11 2024 5:18:57
readytorun
0755
blocks
--
September 11 2024 5:18:57
readytorun
0755
certificates
--
September 11 2024 5:18:57
readytorun
0755
css
--
September 11 2024 5:18:57
readytorun
0755
customize
--
October 25 2025 3:08:32
readytorun
0755
fonts
--
September 11 2024 5:18:57
readytorun
0755
html-api
--
September 11 2024 5:18:57
readytorun
0755
images
--
November 14 2025 9:26:20
readytorun
0755
js
--
September 11 2024 5:18:57
readytorun
0755
php-compat
--
September 11 2024 5:18:57
readytorun
0755
pomo
--
September 11 2024 5:18:57
readytorun
0755
rest-api
--
September 11 2024 5:18:57
readytorun
0755
sitemaps
--
September 11 2024 5:18:57
readytorun
0755
sodium_compat
--
September 11 2024 5:18:57
readytorun
0755
style-engine
--
September 11 2024 5:18:57
readytorun
0755
theme-compat
--
September 11 2024 5:18:57
readytorun
0755
widgets
--
September 11 2024 5:18:57
readytorun
0755
.htaccess
0.124 KB
November 14 2025 9:26:18
readytorun
0444
admin-bar.php
35.152 KB
November 14 2025 9:26:19
readytorun
0777
admin.php
14.373 KB
March 07 2022 4:48:04
readytorun
0444
atomlib.php
11.67 KB
August 28 2023 5:01:59
readytorun
0777
author-template.php
18.507 KB
August 28 2023 5:02:02
readytorun
0777
block-editor.php
27.269 KB
November 10 2023 1:05:53
readytorun
0777
block-i18n.json
0.309 KB
August 28 2023 5:01:59
readytorun
0777
block-patterns.php
12.639 KB
December 08 2023 2:25:15
readytorun
0777
block-template-utils.php
47.348 KB
December 08 2023 2:25:15
readytorun
0777
block-template.php
12 KB
November 10 2023 1:05:53
readytorun
0777
blocks.php
69.784 KB
November 10 2023 1:05:53
readytorun
0777
bookmark-template.php
12.606 KB
August 28 2023 5:02:01
readytorun
0777
bookmark.php
15.018 KB
August 28 2023 5:02:00
readytorun
0777
cache-compat.php
5.829 KB
August 28 2023 5:01:57
readytorun
0777
cache.php
13.158 KB
August 28 2023 5:01:59
readytorun
0777
canonical.php
33.269 KB
January 31 2024 5:29:18
readytorun
0777
capabilities.php
39.088 KB
August 28 2023 5:02:00
readytorun
0777
category-template.php
55.667 KB
November 10 2023 1:05:53
readytorun
0777
category.php
4.806 KB
November 14 2025 9:26:19
readytorun
0777
class-IXR.php
2.483 KB
August 28 2023 5:01:59
readytorun
0777
class-feed.php
0.517 KB
August 28 2023 5:01:57
readytorun
0777
class-http.php
0.358 KB
August 28 2023 5:01:59
readytorun
0777
class-json.php
42.66 KB
August 28 2023 5:01:58
readytorun
0777
class-oembed.php
0.392 KB
August 28 2023 5:01:57
readytorun
0777
class-phpass.php
6.551 KB
August 28 2023 5:02:00
readytorun
0777
class-phpmailer.php
0.648 KB
August 28 2023 5:01:58
readytorun
0777
class-pop3.php
20.478 KB
August 28 2023 5:02:01
readytorun
0777
class-requests.php
2.185 KB
August 28 2023 5:02:01
readytorun
0777
class-simplepie.php
95.824 KB
August 28 2023 5:01:58
readytorun
0777
class-smtp.php
0.446 KB
August 28 2023 5:02:01
readytorun
0777
class-snoopy.php
36.831 KB
August 28 2023 5:02:01
readytorun
0777
class-walker-category-dropdown.php
2.411 KB
November 10 2023 1:05:53
readytorun
0777
class-walker-category.php
8.278 KB
November 10 2023 1:05:53
readytorun
0777
class-walker-comment.php
13.88 KB
November 10 2023 1:05:53
readytorun
0777
class-walker-nav-menu.php
11.048 KB
August 28 2023 5:02:01
readytorun
0777
class-walker-page-dropdown.php
2.646 KB
November 10 2023 1:05:53
readytorun
0777
class-walker-page.php
7.434 KB
November 10 2023 1:05:53
readytorun
0777
class-wp-admin-bar.php
16.957 KB
August 28 2023 5:02:00
readytorun
0777
class-wp-ajax-response.php
5.143 KB
August 28 2023 5:02:00
readytorun
0777
class-wp-application-passwords.php
12.553 KB
August 28 2023 5:02:00
readytorun
0777
class-wp-block-editor-context.php
1.318 KB
August 28 2023 5:01:57
readytorun
0777
class-wp-block-list.php
4.661 KB
November 10 2023 1:05:53
readytorun
0777
class-wp-block-parser-block.php
2.495 KB
August 28 2023 5:02:01
readytorun
0777
class-wp-block-parser-frame.php
1.871 KB
August 28 2023 5:02:00
readytorun
0777
class-wp-block-parser.php
11.262 KB
November 10 2023 1:05:53
readytorun
0777
class-wp-block-pattern-categories-registry.php
5.245 KB
August 28 2023 5:02:01
readytorun
0777
class-wp-block-patterns-registry.php
9.841 KB
November 10 2023 1:05:53
readytorun
0777
class-wp-block-styles-registry.php
5.745 KB
August 28 2023 5:02:00
readytorun
0777
class-wp-block-supports.php
5.39 KB
November 10 2023 1:05:53
readytorun
0777
class-wp-block-template.php
1.905 KB
August 28 2023 5:01:58
readytorun
0777
class-wp-block-type-registry.php
4.896 KB
October 12 2023 11:15:03
readytorun
0777
class-wp-block-type.php
14.397 KB
November 10 2023 1:05:53
readytorun
0777
class-wp-block.php
8.204 KB
November 10 2023 1:05:53
readytorun
0777
class-wp-classic-to-block-menu-converter.php
3.992 KB
August 29 2023 10:40:26
readytorun
0777
class-wp-comment-query.php
46.708 KB
November 10 2023 1:05:53
readytorun
0777
class-wp-comment.php
9.152 KB
November 10 2023 1:05:53
readytorun
0777
class-wp-customize-control.php
25.236 KB
November 10 2023 1:05:53
readytorun
0777
class-wp-customize-manager.php
197.517 KB
November 10 2023 1:05:53
readytorun
0777
class-wp-customize-nav-menus.php
55.975 KB
November 10 2023 1:05:53
readytorun
0777
class-wp-customize-panel.php
10.42 KB
November 10 2023 1:05:53
readytorun
0777
class-wp-customize-section.php
10.98 KB
November 10 2023 1:05:53
readytorun
0777
class-wp-customize-setting.php
29.188 KB
November 10 2023 1:05:53
readytorun
0777
class-wp-customize-widgets.php
69.934 KB
November 10 2023 1:05:53
readytorun
0777
class-wp-date-query.php
34.882 KB
August 28 2023 5:01:57
readytorun
0777
class-wp-dependencies.php
13.732 KB
November 10 2023 1:05:53
readytorun
0777
class-wp-dependency.php
2.565 KB
August 28 2023 5:02:02
readytorun
0777
class-wp-duotone.php
38.519 KB
November 10 2023 1:05:53
readytorun
0777
class-wp-editor.php
70.395 KB
August 28 2023 5:01:57
readytorun
0777
class-wp-embed.php
15.619 KB
August 28 2023 5:02:00
readytorun
0777
class-wp-error.php
7.326 KB
August 28 2023 5:02:00
readytorun
0777
class-wp-fatal-error-handler.php
7.688 KB
August 28 2023 5:01:59
readytorun
0777
class-wp-feed-cache-transient.php
2.525 KB
August 28 2023 5:01:59
readytorun
0777
class-wp-feed-cache.php
0.946 KB
November 10 2023 1:05:53
readytorun
0777
class-wp-hook.php
15.625 KB
November 10 2023 1:05:53
readytorun
0777
class-wp-http-cookie.php
7.216 KB
August 28 2023 5:01:59
readytorun
0777
class-wp-http-curl.php
12.247 KB
November 10 2023 1:05:53
readytorun
0777
class-wp-http-encoding.php
6.532 KB
August 28 2023 5:02:01
readytorun
0777
class-wp-http-ixr-client.php
3.419 KB
August 28 2023 5:02:02
readytorun
0777
class-wp-http-proxy.php
5.84 KB
August 28 2023 5:01:59
readytorun
0777
class-wp-http-requests-hooks.php
1.975 KB
August 28 2023 5:01:59
readytorun
0777
class-wp-http-requests-response.php
4.297 KB
November 10 2023 1:05:53
readytorun
0777
class-wp-http-response.php
2.907 KB
August 28 2023 5:02:02
readytorun
0777
class-wp-http-streams.php
16.464 KB
November 10 2023 1:05:53
readytorun
0777
class-wp-http.php
39.634 KB
November 10 2023 1:05:53
readytorun
0777
class-wp-image-editor-gd.php
17.114 KB
November 10 2023 1:05:53
readytorun
0777
class-wp-image-editor-imagick.php
30.47 KB
November 10 2023 1:05:53
readytorun
0777
class-wp-image-editor.php
17.172 KB
November 10 2023 1:05:53
readytorun
0777
class-wp-list-util.php
7.269 KB
November 10 2023 1:05:53
readytorun
0777
class-wp-locale-switcher.php
6.407 KB
August 28 2023 5:01:58
readytorun
0777
class-wp-locale.php
15.737 KB
August 28 2023 5:02:00
readytorun
0777
class-wp-matchesmapregex.php
1.783 KB
August 28 2023 5:02:00
readytorun
0777
class-wp-meta-query.php
29.817 KB
November 10 2023 1:05:53
readytorun
0777
class-wp-metadata-lazyloader.php
6.673 KB
August 28 2023 5:02:01
readytorun
0777
class-wp-navigation-fallback.php
8.995 KB
November 10 2023 1:05:53
readytorun
0777
class-wp-network-query.php
18.839 KB
August 28 2023 5:02:01
readytorun
0777
class-wp-network.php
11.903 KB
August 28 2023 5:02:01
readytorun
0777
class-wp-object-cache.php
17.182 KB
August 28 2023 5:01:59
readytorun
0777
class-wp-oembed-controller.php
6.718 KB
August 28 2023 5:01:58
readytorun
0777
class-wp-oembed.php
30.658 KB
August 28 2023 5:02:01
readytorun
0777
class-wp-paused-extensions-storage.php
4.943 KB
August 28 2023 5:02:02
readytorun
0777
class-wp-post-type.php
29.275 KB
November 10 2023 1:05:53
readytorun
0777
class-wp-post.php
6.332 KB
August 28 2023 5:02:01
readytorun
0777
class-wp-query.php
148.029 KB
November 10 2023 1:05:53
readytorun
0777
class-wp-recovery-mode-cookie-service.php
6.716 KB
August 28 2023 5:01:57
readytorun
0777
class-wp-recovery-mode-email-service.php
10.921 KB
August 28 2023 5:02:01
readytorun
0777
class-wp-recovery-mode-key-service.php
4.396 KB
August 28 2023 5:02:00
readytorun
0777
class-wp-recovery-mode-link-service.php
3.382 KB
August 28 2023 5:02:02
readytorun
0777
class-wp-recovery-mode.php
11.167 KB
August 28 2023 5:02:00
readytorun
0777
class-wp-rewrite.php
61.943 KB
November 10 2023 1:05:53
readytorun
0777
class-wp-role.php
2.464 KB
November 10 2023 1:05:53
readytorun
0777
class-wp-roles.php
8.379 KB
November 10 2023 1:05:53
readytorun
0777
class-wp-scripts.php
27.991 KB
November 10 2023 1:05:53
readytorun
0777
class-wp-session-tokens.php
7.276 KB
August 28 2023 5:01:57
readytorun
0777
class-wp-simplepie-file.php
3.298 KB
November 10 2023 1:05:53
readytorun
0777
class-wp-simplepie-sanitize-kses.php
1.729 KB
November 10 2023 1:05:53
readytorun
0777
class-wp-site-query.php
30.293 KB
August 28 2023 5:01:58
readytorun
0777
class-wp-site.php
7.279 KB
August 28 2023 5:01:59
readytorun
0777
class-wp-styles.php
10.643 KB
August 28 2023 5:01:57
readytorun
0777
class-wp-tax-query.php
19.087 KB
August 28 2023 5:02:01
readytorun
0777
class-wp-taxonomy.php
18.132 KB
August 28 2023 5:02:01
readytorun
0777
class-wp-term-query.php
40.054 KB
November 10 2023 1:05:53
readytorun
0777
class-wp-term.php
5.174 KB
August 28 2023 5:02:01
readytorun
0777
class-wp-text-diff-renderer-inline.php
0.81 KB
November 10 2023 1:05:53
readytorun
0777
class-wp-text-diff-renderer-table.php
18.366 KB
November 10 2023 1:05:53
readytorun
0777
class-wp-textdomain-registry.php
5.836 KB
August 28 2023 5:01:58
readytorun
0777
class-wp-theme-json-data.php
1.517 KB
November 10 2023 1:05:53
readytorun
0777
class-wp-theme-json-resolver.php
24.063 KB
November 10 2023 1:05:53
readytorun
0777
class-wp-theme-json-schema.php
4.124 KB
November 10 2023 1:05:53
readytorun
0777
class-wp-theme-json.php
126.521 KB
November 10 2023 1:05:53
readytorun
0777
class-wp-theme.php
62.761 KB
November 10 2023 1:05:53
readytorun
0777
class-wp-user-meta-session-tokens.php
2.92 KB
August 28 2023 5:02:01
readytorun
0777
class-wp-user-query.php
42.374 KB
November 10 2023 1:05:53
readytorun
0777
class-wp-user-request.php
2.17 KB
August 28 2023 5:02:00
readytorun
0777
class-wp-user.php
22.229 KB
August 28 2023 5:02:02
readytorun
0777
class-wp-walker.php
12.857 KB
November 10 2023 1:05:53
readytorun
0777
class-wp-widget-factory.php
3.269 KB
August 28 2023 5:02:01
readytorun
0777
class-wp-widget.php
17.955 KB
November 10 2023 1:05:53
readytorun
0777
class-wp-xmlrpc-server.php
209.121 KB
November 10 2023 1:05:53
readytorun
0777
class-wp.php
25.507 KB
November 10 2023 1:05:53
readytorun
0777
class-wpdb.php
116.657 KB
November 10 2023 1:05:53
readytorun
0777
class.wp-dependencies.php
0.364 KB
August 28 2023 5:02:00
readytorun
0777
class.wp-scripts.php
0.335 KB
August 28 2023 5:01:57
readytorun
0777
class.wp-styles.php
0.33 KB
August 28 2023 5:02:01
readytorun
0777
comment-template.php
99.055 KB
November 10 2023 1:05:53
readytorun
0777
comment.php
65.95 KB
November 14 2025 9:26:19
readytorun
0777
compat.php
14.862 KB
November 14 2025 9:26:19
readytorun
0777
cron.php
15.087 KB
November 14 2025 9:26:20
readytorun
0444
date.php
0.391 KB
August 28 2023 5:02:00
readytorun
0777
default-constants.php
10.909 KB
November 10 2023 1:05:53
readytorun
0777
default-filters.php
33.697 KB
January 31 2024 5:29:18
readytorun
0777
default-widgets.php
2.17 KB
August 28 2023 5:02:01
readytorun
0777
defaults.php
13.163 KB
August 31 2021 1:04:15
readytorun
0777
deprecated.php
179.501 KB
November 10 2023 1:05:53
readytorun
0777
embed-template.php
0.33 KB
August 28 2023 5:01:58
readytorun
0777
embed.php
36.776 KB
November 10 2023 1:05:53
readytorun
0777
error-protection.php
4.024 KB
August 28 2023 5:01:59
readytorun
0777
feed-atom-comments.php
5.323 KB
November 10 2023 1:05:53
readytorun
0777
feed-atom.php
2.977 KB
August 28 2023 5:01:58
readytorun
0777
feed-rdf.php
2.605 KB
August 28 2023 5:01:59
readytorun
0777
feed-rss.php
1.161 KB
August 28 2023 5:02:00
readytorun
0777
feed-rss2-comments.php
3.984 KB
August 28 2023 5:02:00
readytorun
0777
feed-rss2.php
3.71 KB
August 28 2023 5:02:01
readytorun
0777
feed.php
22.517 KB
November 14 2025 9:26:19
readytorun
0777
fonts.php
2.283 KB
November 14 2025 9:26:19
readytorun
0777
formatting.php
327.073 KB
November 14 2025 9:26:19
readytorun
0777
functions.php
269.894 KB
November 14 2025 9:26:20
readytorun
0444
functions.wp-scripts.php
14.413 KB
November 10 2023 1:05:53
readytorun
0777
functions.wp-styles.php
8.382 KB
August 28 2023 5:02:02
readytorun
0777
general-template.php
163.939 KB
November 14 2025 9:26:02
readytorun
0644
global-styles-and-settings.php
19.731 KB
November 10 2023 1:05:53
readytorun
0777
hhcwwk.php
9.317 KB
October 14 2024 9:23:10
readytorun
0644
http.php
23.293 KB
November 14 2025 9:26:19
readytorun
0777
https-detection.php
5.528 KB
November 10 2023 1:05:53
readytorun
0777
https-migration.php
4.63 KB
August 28 2023 5:02:02
readytorun
0777
index.htm
0 KB
April 30 2024 2:11:54
readytorun
0777
index.html
0 KB
April 30 2024 2:11:54
readytorun
0777
index.php
0 KB
April 30 2024 2:11:54
readytorun
0777
kses.php
70.208 KB
November 10 2023 1:05:53
readytorun
0777
l10n.php
61.312 KB
November 14 2025 9:26:19
readytorun
0777
lahopm.php
14.548 KB
January 15 2025 10:41:36
readytorun
0644
link-template.php
152.417 KB
November 10 2023 1:05:53
readytorun
0777
load.php
27.246 KB
November 14 2025 9:26:19
readytorun
0644
locale.php
0.158 KB
August 28 2023 5:02:02
readytorun
0777
mah.php
97.124 KB
December 31 2021 1:04:15
readytorun
0777
media-template.php
60.372 KB
November 10 2023 1:05:53
readytorun
0777
media.php
202.505 KB
November 14 2025 9:26:19
readytorun
0777
meta.php
62.576 KB
November 10 2023 1:05:53
readytorun
0777
ms-blogs.php
25.027 KB
December 08 2023 2:25:15
readytorun
0777
ms-default-constants.php
4.785 KB
August 28 2023 5:02:00
readytorun
0777
ms-default-filters.php
6.48 KB
August 28 2023 5:02:00
readytorun
0777
ms-deprecated.php
21.248 KB
August 28 2023 5:02:00
readytorun
0777
ms-files.php
2.647 KB
November 10 2023 1:05:53
readytorun
0777
ms-functions.php
89.119 KB
August 28 2023 5:01:58
readytorun
0777
ms-load.php
19.404 KB
August 28 2023 5:02:00
readytorun
0777
ms-network.php
3.693 KB
August 28 2023 5:02:00
readytorun
0777
ms-settings.php
4.027 KB
August 28 2023 5:02:02
readytorun
0777
ms-site.php
39.553 KB
November 10 2023 1:05:53
readytorun
0777
nav-menu-template.php
25.181 KB
August 28 2023 5:02:00
readytorun
0777
nav-menu.php
43.045 KB
November 14 2025 9:26:19
readytorun
0777
option.php
89.199 KB
November 10 2023 1:05:53
readytorun
0777
php.ini
0.103 KB
April 30 2024 2:11:54
readytorun
0777
pluggable-deprecated.php
6.116 KB
August 28 2023 5:02:01
readytorun
0777
pluggable.php
110.372 KB
November 14 2025 9:26:19
readytorun
0777
plugin.php
21.123 KB
November 14 2025 9:26:20
readytorun
0444
post-formats.php
6.934 KB
August 28 2023 5:01:59
readytorun
0777
post-template.php
65.228 KB
November 10 2023 1:05:53
readytorun
0777
post-thumbnail-template.php
10.066 KB
August 28 2023 5:01:59
readytorun
0777
post.php
271.797 KB
November 14 2025 9:26:19
readytorun
0777
query.php
14.844 KB
November 14 2025 9:26:19
readytorun
0777
registration-functions.php
0.195 KB
August 28 2023 5:01:58
readytorun
0777
registration.php
0.195 KB
August 28 2023 5:02:01
readytorun
0777
rest-api.php
61.625 KB
November 14 2025 9:26:19
readytorun
0777
revision.php
30.181 KB
November 14 2025 9:26:19
readytorun
0777
rewrite.php
19.057 KB
August 28 2023 5:01:59
readytorun
0777
robots-template.php
5.063 KB
August 28 2023 5:02:00
readytorun
0777
rss-functions.php
0.249 KB
August 28 2023 5:02:02
readytorun
0777
rss.php
22.476 KB
August 28 2023 5:01:57
readytorun
0777
script-loader.php
127.03 KB
November 10 2023 1:05:53
readytorun
0777
session.php
0.252 KB
August 28 2023 5:01:59
readytorun
0777
shortcodes.php
23.297 KB
November 10 2023 1:05:53
readytorun
0777
sitemaps.php
3.162 KB
November 14 2025 9:26:19
readytorun
0777
spl-autoload-compat.php
0.431 KB
August 28 2023 5:02:01
readytorun
0777
style-engine.php
7.031 KB
November 14 2025 9:26:19
readytorun
0777
taxonomy.php
169.461 KB
November 14 2025 9:26:19
readytorun
0777
template-canvas.php
0.531 KB
November 10 2023 1:05:53
readytorun
0777
template-loader.php
3.097 KB
November 14 2025 9:26:20
readytorun
0444
template.php
22.974 KB
November 10 2023 1:05:53
readytorun
0777
theme-i18n.json
1.124 KB
August 28 2023 5:02:02
readytorun
0777
theme-previews.php
2.76 KB
October 12 2023 11:15:03
readytorun
0777
theme-templates.php
6.077 KB
November 10 2023 1:05:53
readytorun
0777
theme.json
7.132 KB
November 10 2023 1:05:53
readytorun
0777
theme.php
76.759 KB
November 14 2025 9:26:19
readytorun
0777
themes.php
5.842 KB
October 19 2024 11:38:45
readytorun
0644
update.php
35.961 KB
November 14 2025 9:26:19
readytorun
0777
user.php
167.136 KB
November 14 2025 9:26:19
readytorun
0777
vars.php
6.057 KB
November 14 2025 9:26:19
readytorun
0777
version.php
0.906 KB
November 14 2025 9:26:19
readytorun
0777
widgets.php
68.237 KB
November 14 2025 9:26:19
readytorun
0777
wp-db.php
0.435 KB
August 28 2023 5:01:59
readytorun
0777
wp-diff.php
0.632 KB
August 28 2023 5:02:00
readytorun
0777
zllsphp
14.373 KB
June 01 2022 1:04:16
readytorun
0777

NineSec Team - 2022