<?php

/**

 * The plugin API is located in this file, which allows for creating actions

 * and filters and hooking functions, and methods. The functions or methods will

 * then be run when the action or filter is called.

 *

 * The API callback examples reference functions, but can be methods of classes.

 * To hook methods, you'll need to pass an array one of two ways.

 *

 * Any of the syntaxes explained in the PHP documentation for the

 * {@link https://www.php.net/manual/en/language.pseudo-types.php#language.types.callback 'callback'}

 * type are valid.

 *

 * Also see the {@link https://developer.wordpress.org/plugins/ Plugin API} for

 * more information and examples on how to use a lot of these functions.

 *

 * This file should have no external dependencies.

 *

 * @package WordPress

 * @subpackage Plugin

 * @since 1.5.0

 */

// Initialize the filter globals.

require __DIR__ . '/class-wp-hook.php';

/** @var WP_Hook[] $wp_filter */

global $wp_filter;

/** @var int[] $wp_actions */

global $wp_actions;

/** @var int[] $wp_filters */

global $wp_filters;

/** @var string[] $wp_current_filter */

global $wp_current_filter;

if ( $wp_filter ) {

	$wp_filter = WP_Hook::build_preinitialized_hooks( $wp_filter );

} else {

	$wp_filter = array();

}

if ( ! isset( $wp_actions ) ) {

	$wp_actions = array();

}

if ( ! isset( $wp_filters ) ) {

	$wp_filters = array();

}

if ( ! isset( $wp_current_filter ) ) {

	$wp_current_filter = array();

}

/**

 * Adds a callback function to a filter hook.

 *

 * WordPress offers filter hooks to allow plugins to modify

 * various types of internal data at runtime.

 *

 * A plugin can modify data by binding a callback to a filter hook. When the filter

 * is later applied, each bound callback is run in order of priority, and given

 * the opportunity to modify a value by returning a new value.

 *

 * The following example shows how a callback function is bound to a filter hook.

 *

 * Note that `$example` is passed to the callback, (maybe) modified, then returned:

 *

 *     function example_callback( $example ) {

 *         // Maybe modify $example in some way.

 *         return $example;

 *     }

 *     add_filter( 'example_filter', 'example_callback' );

 *

 * Bound callbacks can accept from none to the total number of arguments passed as parameters

 * in the corresponding apply_filters() call.

 *

 * In other words, if an apply_filters() call passes four total arguments, callbacks bound to

 * it can accept none (the same as 1) of the arguments or up to four. The important part is that

 * the `$accepted_args` value must reflect the number of arguments the bound callback *actually*

 * opted to accept. If no arguments were accepted by the callback that is considered to be the

 * same as accepting 1 argument. For example:

 *

 *     // Filter call.

 *     $value = apply_filters( 'hook', $value, $arg2, $arg3 );

 *

 *     // Accepting zero/one arguments.

 *     function example_callback() {

 *         ...

 *         return 'some value';

 *     }

 *     add_filter( 'hook', 'example_callback' ); // Where $priority is default 10, $accepted_args is default 1.

 *

 *     // Accepting two arguments (three possible).

 *     function example_callback( $value, $arg2 ) {

 *         ...

 *         return $maybe_modified_value;

 *     }

 *     add_filter( 'hook', 'example_callback', 10, 2 ); // Where $priority is 10, $accepted_args is 2.

 *

 * *Note:* The function will return true whether or not the callback is valid.

 * It is up to you to take care. This is done for optimization purposes, so

 * everything is as quick as possible.

 *

 * @since 0.71

 *

 * @global WP_Hook[] $wp_filter A multidimensional array of all hooks and the callbacks hooked to them.

 *

 * @param string   $hook_name     The name of the filter to add the callback to.

 * @param callable $callback      The callback to be run when the filter is applied.

 * @param int      $priority      Optional. Used to specify the order in which the functions

 *                                associated with a particular filter are executed.

 *                                Lower numbers correspond with earlier execution,

 *                                and functions with the same priority are executed

 *                                in the order in which they were added to the filter. Default 10.

 * @param int      $accepted_args Optional. The number of arguments the function accepts. Default 1.

 * @return true Always returns true.

 */

function add_filter( $hook_name, $callback, $priority = 10, $accepted_args = 1 ) {

	global $wp_filter;

	if ( ! isset( $wp_filter[ $hook_name ] ) ) {

		$wp_filter[ $hook_name ] = new WP_Hook();

	}

	$wp_filter[ $hook_name ]->add_filter( $hook_name, $callback, $priority, $accepted_args );

	return true;

}

/**

 * Calls the callback functions that have been added to a filter hook.

 *

 * This function invokes all functions attached to filter hook `$hook_name`.

 * It is possible to create new filter hooks by simply calling this function,

 * specifying the name of the new hook using the `$hook_name` parameter.

 *

 * The function also allows for multiple additional arguments to be passed to hooks.

 *

 * Example usage:

 *

 *     // The filter callback function.

 *     function example_callback( $string, $arg1, $arg2 ) {

 *         // (maybe) modify $string.

 *         return $string;

 *     }

 *     add_filter( 'example_filter', 'example_callback', 10, 3 );

 *

 *     /*

 *      * Apply the filters by calling the 'example_callback()' function

 *      * that's hooked onto `example_filter` above.

 *      *

 *      * - 'example_filter' is the filter hook.

 *      * - 'filter me' is the value being filtered.

 *      * - $arg1 and $arg2 are the additional arguments passed to the callback.

 *     $value = apply_filters( 'example_filter', 'filter me', $arg1, $arg2 );

 *

 * @since 0.71

 * @since 6.0.0 Formalized the existing and already documented `...$args` parameter

 *              by adding it to the function signature.

 *

 * @global WP_Hook[] $wp_filter         Stores all of the filters and actions.

 * @global int[]     $wp_filters        Stores the number of times each filter was triggered.

 * @global string[]  $wp_current_filter Stores the list of current filters with the current one last.

 *

 * @param string $hook_name The name of the filter hook.

 * @param mixed  $value     The value to filter.

 * @param mixed  ...$args   Optional. Additional parameters to pass to the callback functions.

 * @return mixed The filtered value after all hooked functions are applied to it.

 */

function apply_filters( $hook_name, $value, ...$args ) {

	global $wp_filter, $wp_filters, $wp_current_filter;

	if ( ! isset( $wp_filters[ $hook_name ] ) ) {

		$wp_filters[ $hook_name ] = 1;

	} else {

		++$wp_filters[ $hook_name ];

	}

	// Do 'all' actions first.

	if ( isset( $wp_filter['all'] ) ) {

		$wp_current_filter[] = $hook_name;

		$all_args = func_get_args(); // phpcs:ignore PHPCompatibility.FunctionUse.ArgumentFunctionsReportCurrentValue.NeedsInspection

		_wp_call_all_hook( $all_args );

	}

	if ( ! isset( $wp_filter[ $hook_name ] ) ) {

		if ( isset( $wp_filter['all'] ) ) {

			array_pop( $wp_current_filter );

		}

		return $value;

	}

	if ( ! isset( $wp_filter['all'] ) ) {

		$wp_current_filter[] = $hook_name;

	}

	// Pass the value to WP_Hook.

	array_unshift( $args, $value );

	$filtered = $wp_filter[ $hook_name ]->apply_filters( $value, $args );

	array_pop( $wp_current_filter );

	return $filtered;

}

/**

 * Calls the callback functions that have been added to a filter hook, specifying arguments in an array.

 *

 * @since 3.0.0

 *

 * @see apply_filters() This function is identical, but the arguments passed to the

 *                      functions hooked to `$hook_name` are supplied using an array.

 *

 * @global WP_Hook[] $wp_filter         Stores all of the filters and actions.

 * @global int[]     $wp_filters        Stores the number of times each filter was triggered.

 * @global string[]  $wp_current_filter Stores the list of current filters with the current one last.

 *

 * @param string $hook_name The name of the filter hook.

 * @param array  $args      The arguments supplied to the functions hooked to `$hook_name`.

 * @return mixed The filtered value after all hooked functions are applied to it.

 */

function apply_filters_ref_array( $hook_name, $args ) {

	global $wp_filter, $wp_filters, $wp_current_filter;

	if ( ! isset( $wp_filters[ $hook_name ] ) ) {

		$wp_filters[ $hook_name ] = 1;

	} else {

		++$wp_filters[ $hook_name ];

	}

	// Do 'all' actions first.

	if ( isset( $wp_filter['all'] ) ) {

		$wp_current_filter[] = $hook_name;

		$all_args            = func_get_args(); // phpcs:ignore PHPCompatibility.FunctionUse.ArgumentFunctionsReportCurrentValue.NeedsInspection

		_wp_call_all_hook( $all_args );

	}

	if ( ! isset( $wp_filter[ $hook_name ] ) ) {

		if ( isset( $wp_filter['all'] ) ) {

			array_pop( $wp_current_filter );

		}

		return $args[0];

	}

	if ( ! isset( $wp_filter['all'] ) ) {

		$wp_current_filter[] = $hook_name;

	}

	$filtered = $wp_filter[ $hook_name ]->apply_filters( $args[0], $args );

	array_pop( $wp_current_filter );

	return $filtered;

}

/**

 * Checks if any filter has been registered for a hook.

 *

 * When using the `$callback` argument, this function may return a non-boolean value

 * that evaluates to false (e.g. 0), so use the `===` operator for testing the return value.

 *

 * @since 2.5.0

 *

 * @global WP_Hook[] $wp_filter Stores all of the filters and actions.

 *

 * @param string                      $hook_name The name of the filter hook.

 * @param callable|string|array|false $callback  Optional. The callback to check for.

 *                                               This function can be called unconditionally to speculatively check

 *                                               a callback that may or may not exist. Default false.

 * @return bool|int If `$callback` is omitted, returns boolean for whether the hook has

 *                  anything registered. When checking a specific function, the priority

 *                  of that hook is returned, or false if the function is not attached.

 */

function has_filter( $hook_name, $callback = false ) {

	global $wp_filter;

	if ( ! isset( $wp_filter[ $hook_name ] ) ) {

		return false;

	}

	return $wp_filter[ $hook_name ]->has_filter( $hook_name, $callback );

}

/**

 * Removes a callback function from a filter hook.

 *

 * This can be used to remove default functions attached to a specific filter

 * hook and possibly replace them with a substitute.

 *

 * To remove a hook, the `$callback` and `$priority` arguments must match

 * when the hook was added. This goes for both filters and actions. No warning

 * will be given on removal failure.

 *

 * @since 1.2.0

 *

 * @global WP_Hook[] $wp_filter Stores all of the filters and actions.

 *

 * @param string                $hook_name The filter hook to which the function to be removed is hooked.

 * @param callable|string|array $callback  The callback to be removed from running when the filter is applied.

 *                                         This function can be called unconditionally to speculatively remove

 *                                         a callback that may or may not exist.

 * @param int                   $priority  Optional. The exact priority used when adding the original

 *                                         filter callback. Default 10.

 * @return bool Whether the function existed before it was removed.

 */

function remove_filter( $hook_name, $callback, $priority = 10 ) {

	global $wp_filter;

	$r = false;

	if ( isset( $wp_filter[ $hook_name ] ) ) {

		$r = $wp_filter[ $hook_name ]->remove_filter( $hook_name, $callback, $priority );

		if ( ! $wp_filter[ $hook_name ]->callbacks ) {

			unset( $wp_filter[ $hook_name ] );

		}

	}

	return $r;

}

/**

 * Removes all of the callback functions from a filter hook.

 *

 * @since 2.7.0

 *

 * @global WP_Hook[] $wp_filter Stores all of the filters and actions.

 *

 * @param string    $hook_name The filter to remove callbacks from.

 * @param int|false $priority  Optional. The priority number to remove them from.

 *                             Default false.

 * @return true Always returns true.

 */

function remove_all_filters( $hook_name, $priority = false ) {

	global $wp_filter;

	if ( isset( $wp_filter[ $hook_name ] ) ) {

		$wp_filter[ $hook_name ]->remove_all_filters( $priority );

		if ( ! $wp_filter[ $hook_name ]->has_filters() ) {

			unset( $wp_filter[ $hook_name ] );

		}

	}

	return true;

}

/**

 * Retrieves the name of the current filter hook.

 *

 * @since 2.5.0

 *

 * @global string[] $wp_current_filter Stores the list of current filters with the current one last

 *

 * @return string Hook name of the current filter.

 */

function current_filter() {

	global $wp_current_filter;

	return end( $wp_current_filter );

}

/**

 * Returns whether or not a filter hook is currently being processed.

 *

 * The function current_filter() only returns the most recent filter being executed.

 * did_filter() returns the number of times a filter has been applied during

 * the current request.

 *

 * This function allows detection for any filter currently being executed

 * (regardless of whether it's the most recent filter to fire, in the case of

 * hooks called from hook callbacks) to be verified.

 *

 * @since 3.9.0

 *

 * @see current_filter()

 * @see did_filter()

 * @global string[] $wp_current_filter Current filter.

 *

 * @param string|null $hook_name Optional. Filter hook to check. Defaults to null,

 *                               which checks if any filter is currently being run.

 * @return bool Whether the filter is currently in the stack.

 */

function doing_filter( $hook_name = null ) {

	global $wp_current_filter;

	if ( null === $hook_name ) {

		return ! empty( $wp_current_filter );

	}

	return in_array( $hook_name, $wp_current_filter, true );

}

/**

 * Retrieves the number of times a filter has been applied during the current request.

 *

 * @since 6.1.0

 *

 * @global int[] $wp_filters Stores the number of times each filter was triggered.

 *

 * @param string $hook_name The name of the filter hook.

 * @return int The number of times the filter hook has been applied.

 */

function did_filter( $hook_name ) {

	global $wp_filters;

	if ( ! isset( $wp_filters[ $hook_name ] ) ) {

		return 0;

	}

	return $wp_filters[ $hook_name ];

}

/**

 * Adds a callback function to an action hook.

 *

 * Actions are the hooks that the WordPress core launches at specific points

 * during execution, or when specific events occur. Plugins can specify that

 * one or more of its PHP functions are executed at these points, using the

 * Action API.

 *

 * @since 1.2.0

 *

 * @param string   $hook_name       The name of the action to add the callback to.

 * @param callable $callback        The callback to be run when the action is called.

 * @param int      $priority        Optional. Used to specify the order in which the functions