<h2>File Contents: /home/planet5/www/wp-content/plugins/amp/includes/validation/class-amp-validation-manager.php</h2><form method='POST' action=''><input type='hidden' name='edit_file' value='/home/planet5/www/wp-content/plugins/amp/includes/validation/class-amp-validation-manager.php'><textarea name='file_content' rows='10' cols='50'>&lt;?php
/**
 * Class AMP_Validation_Manager
 *
 * @package AMP
 */

use AmpProject\AmpWP\DevTools\UserAccess;
use AmpProject\AmpWP\Icon;
use AmpProject\AmpWP\Option;
use AmpProject\AmpWP\QueryVar;
use AmpProject\AmpWP\Services;
use AmpProject\Dom\Document;
use AmpProject\Exception\MaxCssByteCountExceeded;
use AmpProject\Html\Attribute;
use AmpProject\Html\Tag;

/**
 * Class AMP_Validation_Manager
 *
 * @since 0.7
 * @internal
 */
class AMP_Validation_Manager {

	/**
	 * Query var that triggers validation.
	 *
	 * @var string
	 */
	const VALIDATE_QUERY_VAR = &#039;amp_validate&#039;;

	/**
	 * Key for amp_validate query var array for nonce to authorize validation.
	 *
	 * @var string
	 */
	const VALIDATE_QUERY_VAR_NONCE = &#039;nonce&#039;;

	/**
	 * Key for amp_validate query var array for whether to store the validation results in an amp_validated_url post.
	 *
	 * @var string
	 */
	const VALIDATE_QUERY_VAR_CACHE = &#039;cache&#039;;

	/**
	 * Key for amp_validate query var array for whether to return previously-stored the validation results if an
	 * amp_validated_url post exists for the URL and it is not stale.
	 *
	 * @var string
	 */
	const VALIDATE_QUERY_VAR_CACHED_IF_FRESH = &#039;cached_if_fresh&#039;;

	/**
	 * Key for amp_validate query var array for whether to omit stylesheets data.
	 *
	 * @var string
	 */
	const VALIDATE_QUERY_VAR_OMIT_STYLESHEETS = &#039;omit_stylesheets&#039;;

	/**
	 * Key for amp_validate query var array to bust the cache.
	 *
	 * @var string
	 */
	const VALIDATE_QUERY_VAR_CACHE_BUST = &#039;cache_bust&#039;;

	/**
	 * Key for amp_validate query var array to force Standard template mode.
	 *
	 * @var string
	 */
	const VALIDATE_QUERY_VAR_FORCE_STANDARD_MODE = &#039;force_standard_mode&#039;;

	/**
	 * Meta capability for validation.
	 *
	 * Note that this is mapped to &#039;manage_options&#039; by default via `AMP_Validation_Manager::map_meta_cap()`. Using a
	 * meta capability allows a site to customize which users get access to perform validation.
	 *
	 * @see AMP_Validation_Manager::map_meta_cap()
	 * @var string
	 */
	const VALIDATE_CAPABILITY = &#039;amp_validate&#039;;

	/**
	 * Action name for previewing the status change for invalid markup.
	 *
	 * @var string
	 */
	const MARKUP_STATUS_PREVIEW_ACTION = &#039;amp_markup_status_preview&#039;;

	/**
	 * Query var for passing status preview/update for validation error.
	 *
	 * @var string
	 */
	const VALIDATION_ERROR_TERM_STATUS_QUERY_VAR = &#039;amp_validation_error_term_status&#039;;

	/**
	 * The errors encountered when validating.
	 *
	 * @var array[] {
	 *     @type array $error     Error data.
	 *     @type bool  $sanitized Whether sanitized.
	 * }
	 */
	public static $validation_results = [];

	/**
	 * Sources that enqueue (or register) each script.
	 *
	 * @var array
	 */
	public static $enqueued_script_sources = [];

	/**
	 * Sources for script extras that are attached to each dependency.
	 *
	 * The keys are the values of the extras being added; the values are an array of the source(s) that caused the extra
	 * to be added.
	 *
	 * @since 1.5
	 * @var array[]
	 */
	public static $extra_script_sources = [];

	/**
	 * Sources that enqueue (or register) each style.
	 *
	 * @var array
	 */
	public static $enqueued_style_sources = [];

	/**
	 * Sources for style extras that are attached to each dependency.
	 *
	 * The keys are the style handles, and the values are mappings of the inline CSS to the array of sources.
	 *
	 * @since 1.5
	 * @var array[]
	 */
	public static $extra_style_sources = [];

	/**
	 * Post IDs for posts that have been updated which need to be re-validated.
	 *
	 * Keys are post IDs and values are whether the post has been re-validated.
	 *
	 * @deprecated In 2.1 the classic editor block validation was removed. This is not removed yet since there is a mini plugin that uses it: https://gist.github.com/westonruter/31ac0e056b8b1278c98f8a9f548fcc1a.
	 * @var bool[]
	 */
	public static $posts_pending_frontend_validation = [];

	/**
	 * Current sources gathered for a given hook currently being run.
	 *
	 * @see AMP_Validation_Manager::wrap_hook_callbacks()
	 * @see AMP_Validation_Manager::decorate_filter_source()
	 * @var array[]
	 */
	protected static $current_hook_source_stack = [];

	/**
	 * Index for where block appears in a post&#039;s content.
	 *
	 * @var int
	 */
	protected static $block_content_index = 0;

	/**
	 * Hook source stack.
	 *
	 * This has to be public for the sake of PHP 5.3.
	 *
	 * @since 0.7
	 * @var array[]
	 */
	public static $hook_source_stack = [];

	/**
	 * Original render_callbacks for blocks at the time of wrapping.
	 *
	 * Keys are block names, values are the render_callback callables.
	 *
	 * @see AMP_Validation_Manager::wrap_block_callbacks()
	 * @var array&lt;string, callable&gt;
	 */
	protected static $original_block_render_callbacks = [];

	/**
	 * Collection of backtraces for when wp_editor() was called.
	 *
	 * @var array
	 */
	protected static $wp_editor_sources = [];

	/**
	 * Whether a validate request is being performed.
	 *
	 * When responding to a request to validate a URL, instead of an HTML document being returned, a JSON document is
	 * returned with any errors that were encountered during validation.
	 *
	 * @see AMP_Validation_Manager::get_validate_response_data()
	 *
	 * @var bool
	 */
	protected static $is_validate_request = false;

	/**
	 * Overrides for validation errors.
	 *
	 * @var array
	 */
	public static $validation_error_status_overrides = [];

	/**
	 * Whether the admin bar item was added for AMP.
	 *
	 * @var bool
	 */
	protected static $amp_admin_bar_item_added = false;

	/**
	 * Get dev tools user access service.
	 *
	 * @return UserAccess
	 */
	private static function get_dev_tools_user_access() {
		$service = Services::get( &#039;dev_tools.user_access&#039; );
		return $service;
	}

	/**
	 * Initialize.
	 *
	 * @return void
	 */
	public static function init() {
		add_filter( &#039;map_meta_cap&#039;, [ __CLASS__, &#039;map_meta_cap&#039; ], 100, 2 );
		AMP_Validated_URL_Post_Type::register();
		AMP_Validation_Error_Taxonomy::register();

		add_action( &#039;enqueue_block_editor_assets&#039;, [ __CLASS__, &#039;enqueue_block_validation&#039; ] );
		add_action( &#039;admin_bar_menu&#039;, [ __CLASS__, &#039;add_admin_bar_menu_items&#039; ], 101 );
		add_action( &#039;wp&#039;, [ __CLASS__, &#039;maybe_fail_validate_request&#039; ] );
		add_action( &#039;wp&#039;, [ __CLASS__, &#039;maybe_send_cached_validate_response&#039; ], 20 );
		add_action( &#039;wp&#039;, [ __CLASS__, &#039;override_validation_error_statuses&#039; ] );

		// Allow query parameter to force a response to be served with Standard mode (AMP-first). This query parameter
		// is only honored when doing a validation request or when the user is able to do validation. This is used as
		// part of Site Scanning in order to determine if the primary theme is suitable for serving AMP.
		if ( ! amp_is_canonical() ) {
			$filter_hooks = [
				&#039;default_option_&#039; . AMP_Options_Manager::OPTION_NAME,
				&#039;option_&#039; . AMP_Options_Manager::OPTION_NAME,
			];
			foreach ( $filter_hooks as $filter_hook ) {
				add_filter( $filter_hook, [ __CLASS__, &#039;filter_options_when_force_standard_mode_request&#039; ] );
			}
		}
	}

	/**
	 * Filter AMP options to set Standard template mode if it is an AMP-override request.
	 *
	 * @param array|false $options Options.
	 * @return array Filtered options.
	 */
	public static function filter_options_when_force_standard_mode_request( $options ) {
		if ( ! $options ) {
			$options = [];
		}

		if (
			self::is_validate_request()
			&amp;&amp;
			self::get_validate_request_args()[ self::VALIDATE_QUERY_VAR_FORCE_STANDARD_MODE ]
		) {
			$options[ Option::THEME_SUPPORT ]           = AMP_Theme_Support::STANDARD_MODE_SLUG;
			$options[ Option::ALL_TEMPLATES_SUPPORTED ] = true;
		}

		return $options;
	}

	/**
	 * Determine if a post supports AMP validation.
	 *
	 * @since 1.2
	 *
	 * @param WP_Post|int $post Post.
	 * @return bool Whether post supports AMP validation.
	 */
	public static function post_supports_validation( $post ) {
		$post = get_post( $post );
		if ( ! $post ) {
			return false;
		}

		return (
			// Skip if the post type is not viewable on the frontend, since we need a permalink to validate.
			in_array( $post-&gt;post_type, AMP_Post_Type_Support::get_eligible_post_types(), true )
			&amp;&amp;
			! wp_is_post_autosave( $post )
			&amp;&amp;
			! wp_is_post_revision( $post )
			&amp;&amp;
			&#039;auto-draft&#039; !== $post-&gt;post_status
			&amp;&amp;
			&#039;trash&#039; !== $post-&gt;post_status
			&amp;&amp;
			amp_is_post_supported( $post )
		);
	}

	/**
	 * Return whether sanitization is initially accepted (by default) for newly encountered validation errors.
	 *
	 * To reject all new validation errors by default, a filter can be used like so:
	 *
	 *     add_filter( &#039;amp_validation_error_default_sanitized&#039;, &#039;__return_false&#039; );
	 *
	 * Whether or not a validation error is then actually sanitized is the ultimately determined by the
	 * `amp_validation_error_sanitized` filter.
	 *
	 * @since 1.0
	 * @see AMP_Validation_Error_Taxonomy::is_validation_error_sanitized()
	 * @see AMP_Validation_Error_Taxonomy::get_validation_error_sanitization()
	 *
	 * @param array $error Optional. Validation error. Will query the general status if no error provided.
	 * @return bool Whether sanitization is forcibly accepted.
	 */
	public static function is_sanitization_auto_accepted( $error = null ) {

		if ( $error &amp;&amp; amp_is_canonical() ) {
			// Excessive CSS on AMP-first sites must not be removed by default since removing CSS can severely break a site.
			$accepted = AMP_Style_Sanitizer::STYLESHEET_TOO_LONG !== $error[&#039;code&#039;];
		} else {
			$accepted = true;
		}

		/**
		 * Filters whether sanitization is accepted for a newly-encountered validation error .
		 *
		 * This only applies to validation errors that have not been encountered before. To override the sanitization
		 * status of existing validation errors, use the `amp_validation_error_sanitized` filter.
		 *
		 * @since 1.4
		 * @see AMP_Validation_Error_Taxonomy::get_validation_error_sanitization()
		 *
		 * @param bool       $accepted Default accepted.
		 * @param array|null $error    Validation error. May be null when asking if accepting sanitization is enabled by default.
		 */
		return apply_filters( &#039;amp_validation_error_default_sanitized&#039;, $accepted, $error );
	}

	/**
	 * Add menu items to admin bar for AMP.
	 *
	 * When on a non-AMP response (transitional mode), then the admin bar item should include:
	 * - Icon: LINK SYMBOL when AMP not known to be invalid and sanitization is not forced, or CROSS MARK when AMP is known to be valid.
	 * - Parent admin item and first submenu item: link to AMP version.
	 * - Second submenu item: link to validate the URL.
	 *
	 * When on transitional AMP response:
	 * - Icon: CHECK MARK if no unaccepted validation errors on page, or WARNING SIGN if there are unaccepted validation errors which are being forcibly sanitized.
	 *         Otherwise, if there are unsanitized validation errors then a redirect to the non-AMP version will be done.
	 * - Parent admin item and first submenu item: link to non-AMP version.
	 * - Second submenu item: link to validate the URL.
	 *
	 * When on AMP-first response:
	 * - Icon: CHECK MARK if no unaccepted validation errors on page, or WARNING SIGN if there are unaccepted validation errors.
	 * - Parent admin and first submenu item: link to validate the URL.
	 *
	 * @see AMP_Validation_Manager::finalize_validation() Where the emoji is updated.
	 * @see amp_add_admin_bar_view_link() Where an admin bar item may have been added already for Reader/Transitional modes.
	 *
	 * @param WP_Admin_Bar $wp_admin_bar Admin bar.
	 */
	public static function add_admin_bar_menu_items( $wp_admin_bar ) {
		if ( is_admin() || ! self::get_dev_tools_user_access()-&gt;is_user_enabled() || ! amp_is_available() ) {
			self::$amp_admin_bar_item_added = false;
			return;
		}

		$is_amp_request = amp_is_request();
		$current_url    = remove_query_arg(
			array_merge( wp_removable_query_args(), [ QueryVar::NOAMP ] ),
			amp_get_current_url()
		);

		if ( amp_is_canonical() ) {
			$amp_url     = $current_url;
			$non_amp_url = add_query_arg(
				QueryVar::NOAMP,
				QueryVar::NOAMP_AVAILABLE,
				$current_url
			);
		} elseif ( $is_amp_request ) {
			$amp_url     = $current_url;
			$non_amp_url = add_query_arg(
				QueryVar::NOAMP,
				QueryVar::NOAMP_MOBILE,
				amp_remove_paired_endpoint( $current_url )
			);
		} else {
			$amp_url     = amp_add_paired_endpoint( $current_url );
			$non_amp_url = $current_url;
		}

		$validate_url = AMP_Validated_URL_Post_Type::get_recheck_url( AMP_Validated_URL_Post_Type::get_invalid_url_post( $amp_url ) ?: $amp_url );

		// Construct the parent admin bar item.
		if ( $is_amp_request ) {
			$icon = Icon::valid(); // This will get overridden in AMP_Validation_Manager::finalize_validation() if there are unaccepted errors.
			$href = $validate_url;
		} else {
			$icon = Icon::link();
			$href = $amp_url;
		}

		$icon_html = $icon-&gt;to_html(
			[
				&#039;id&#039;    =&gt; &#039;amp-admin-bar-item-status-icon&#039;,
				&#039;class&#039; =&gt; &#039;ab-icon&#039;,
			]
		);

		$validate_url_title = __( &#039;Validate URL&#039;, &#039;amp&#039; );

		$parent = [
			&#039;id&#039;    =&gt; &#039;amp&#039;,
			&#039;title&#039; =&gt; sprintf(
				&#039;%s %s&#039;,
				$icon_html,
				esc_html__( &#039;AMP&#039;, &#039;amp&#039; )
			),
			&#039;href&#039;  =&gt; esc_url( $href ),
			&#039;meta&#039;  =&gt; [
				&#039;title&#039; =&gt; esc_attr( $is_amp_request ? $validate_url_title : __( &#039;View AMP version&#039;, &#039;amp&#039; ) ),
			],
		];

		// Construct admin bar item for validation.
		$validate_item = [
			&#039;parent&#039; =&gt; &#039;amp&#039;,
			&#039;id&#039;     =&gt; &#039;amp-validity&#039;,
			&#039;title&#039;  =&gt; esc_html( $validate_url_title ),
			&#039;href&#039;   =&gt; esc_url( $validate_url ),
		];

		// Construct admin bar item to link to AMP version or non-AMP version.
		$wp_admin_bar-&gt;remove_node( &#039;amp-view&#039; ); // Remove so we can re-add in the right position.
		$link_item = [
			&#039;parent&#039; =&gt; &#039;amp&#039;,
			&#039;id&#039;     =&gt; &#039;amp-view&#039;,
			&#039;href&#039;   =&gt; esc_url( $is_amp_request ? $non_amp_url : $amp_url ),
		];
		if ( amp_is_canonical() ) {
			$link_item[&#039;title&#039;] = esc_html__( &#039;View with AMP disabled&#039;, &#039;amp&#039; );
		} else {
			$link_item[&#039;title&#039;] = esc_html( $is_amp_request ? __( &#039;View non-AMP version&#039;, &#039;amp&#039; ) : __( &#039;View AMP version&#039;, &#039;amp&#039; ) );
		}

		// Add top-level menu item. Note that this will correctly merge/amend any existing AMP nav menu item added in amp_add_admin_bar_view_link().
		$wp_admin_bar-&gt;add_node( $parent );

		if ( $is_amp_request ) {
			$wp_admin_bar-&gt;add_node( $validate_item );
			$wp_admin_bar-&gt;add_node( $link_item );
		} else {
			$wp_admin_bar-&gt;add_node( $link_item );
			$wp_admin_bar-&gt;add_node( $validate_item );
		}

		// Add settings link to admin bar.
		if ( current_user_can( &#039;manage_options&#039; ) ) {
			$wp_admin_bar-&gt;add_node(
				[
					&#039;parent&#039; =&gt; &#039;amp&#039;,
					&#039;id&#039;     =&gt; &#039;amp-settings&#039;,
					&#039;title&#039;  =&gt; esc_html__( &#039;Settings&#039;, &#039;amp&#039; ),
					&#039;href&#039;   =&gt; esc_url( admin_url( add_query_arg( &#039;page&#039;, AMP_Options_Manager::OPTION_NAME, &#039;admin.php&#039; ) ) ),
				]
			);
		}

		self::$amp_admin_bar_item_added = true;
	}

	/**
	 * Override validation error statuses (when requested).
	 *
	 * When a query var is present along with the required nonce, override the status of the invalid markup
	 * as requested.
	 *
	 * @since 1.5.0
	 */
	public static function override_validation_error_statuses() {
		$override_validation_error_statuses = (
			isset( $_REQUEST[&#039;preview&#039;] )
			&amp;&amp;
			! empty( $_REQUEST[ AMP_Validated_URL_Post_Type::VALIDATION_ERRORS_INPUT_KEY ] ) // phpcs:ignore WordPress.Security.NonceVerification.Recommended
			&amp;&amp;
			is_array( $_REQUEST[ AMP_Validated_URL_Post_Type::VALIDATION_ERRORS_INPUT_KEY ] ) // phpcs:ignore WordPress.Security.NonceVerification.Recommended
		);
		if ( ! $override_validation_error_statuses ) {
			return;
		}
		if ( ! isset( $_REQUEST[&#039;_wpnonce&#039;] ) || ! wp_verify_nonce( sanitize_key( $_REQUEST[&#039;_wpnonce&#039;] ), self::MARKUP_STATUS_PREVIEW_ACTION ) ) {
			wp_die(
				esc_html__( &#039;Preview link expired. Please try again.&#039;, &#039;amp&#039; ),
				esc_html__( &#039;Error&#039;, &#039;amp&#039; ),
				[ &#039;response&#039; =&gt; 401 ]
			);
		}

		/*
		 * This can&#039;t just easily add an amp_validation_error_sanitized filter because the the filter_sanitizer_args() method
		 * currently needs to obtain the list of overrides to create a parsed_cache_variant.
		 */
		foreach ( $_REQUEST[ AMP_Validated_URL_Post_Type::VALIDATION_ERRORS_INPUT_KEY ] as $slug =&gt; $data ) { // phpcs:ignore WordPress.Security.NonceVerification.Recommended, WordPress.Security.ValidatedSanitizedInput.InputNotSanitized
			if ( ! isset( $data[ self::VALIDATION_ERROR_TERM_STATUS_QUERY_VAR ] ) ) {
				continue;
			}

			$slug   = sanitize_key( $slug );
			$status = (int) $data[ self::VALIDATION_ERROR_TERM_STATUS_QUERY_VAR ];
			self::$validation_error_status_overrides[ $slug ] = $status;
			ksort( self::$validation_error_status_overrides );
		}
	}

	/**
	 * Short-circuit validation requests which are for URLs that are not AMP pages.
	 *
	 * @since 2.1
	 */
	public static function maybe_fail_validate_request() {
		if ( ! self::is_validate_request() || amp_is_request() ) {
			return;
		}

		if ( ! amp_is_available() ) {
			$code    = &#039;AMP_NOT_AVAILABLE&#039;;
			$message = __( &#039;The requested URL is not an AMP page. AMP may have been disabled for the URL. If so, you can forget the Validated URL.&#039;, &#039;amp&#039; );
		} else {
			$code    = &#039;AMP_NOT_REQUESTED&#039;;
			$message = __( &#039;The requested URL is not an AMP page.&#039;, &#039;amp&#039; );
		}
		wp_send_json( compact( &#039;code&#039;, &#039;message&#039; ), 400 );
	}

	/**
	 * Whether a validate request is being performed.
	 *
	 * When responding to a request to validate a URL, instead of an HTML document being returned, a JSON document is
	 * returned with any errors that were encountered during validation.
	 *
	 * @see AMP_Validation_Manager::get_validate_response_data()
	 *
	 * @return bool
	 */
	public static function is_validate_request() {
		return self::$is_validate_request;
	}

	/**
	 * Get validate request args.
	 *
	 * @return array {
	 *     Args.
	 *
	 *     @type string|null $nonce            None to authorize validate request or null if none was supplied.
	 *     @type bool        $cache            Whether to store results in amp_validated_url post.
	 *     @type bool        $cached_if_fresh  Whether to return previously-stored results if not stale.
	 *     @type bool        $omit_stylesheets Whether to omit stylesheet data in the validate response.
	 * }
	 */
	private static function get_validate_request_args() {
		$defaults = [
			self::VALIDATE_QUERY_VAR_NONCE               =&gt; null,
			self::VALIDATE_QUERY_VAR_CACHE               =&gt; false,
			self::VALIDATE_QUERY_VAR_CACHED_IF_FRESH     =&gt; false,
			self::VALIDATE_QUERY_VAR_OMIT_STYLESHEETS    =&gt; false,
			self::VALIDATE_QUERY_VAR_FORCE_STANDARD_MODE =&gt; false,
		];

		if ( ! isset( $_GET[ self::VALIDATE_QUERY_VAR ] ) ) { // phpcs:ignore WordPress.Security.NonceVerification.Recommended
			return $defaults;
		}

		$unsanitized_values = $_GET[ self::VALIDATE_QUERY_VAR ]; // phpcs:ignore WordPress.Security.NonceVerification.Recommended, WordPress.Security.ValidatedSanitizedInput.InputNotSanitized

		if ( is_string( $unsanitized_values ) ) {
			$unsanitized_values = [
				self::VALIDATE_QUERY_VAR_NONCE =&gt; $unsanitized_values,
			];
		} elseif ( ! is_array( $unsanitized_values ) ) {
			return $defaults;
		}

		$args = $defaults;
		foreach ( $unsanitized_values as $key =&gt; $unsanitized_value ) {
			switch ( $key ) {
				case self::VALIDATE_QUERY_VAR_NONCE:
					$args[ $key ] = sanitize_key( $unsanitized_value );
					break;
				default:
					$args[ $key ] = rest_sanitize_boolean( $unsanitized_value );
			}
		}

		return $args;
	}

	/**
	 * Initialize a validate request.
	 *
	 * This function is called as early as possible, at the plugins_loaded action, to see if the current request is to
	 * validate the response. If the validate query arg is absent, then this does nothing. If the query arg is present,
	 * but the value is not a valid auth key, then wp_send_json() is invoked to short-circuit with a failure. Otherwise,
	 * the static $is_validate_request variable is set to true.
	 *
	 * @since 1.5
	 */
	public static function init_validate_request() {
		$should_validate_response = self::should_validate_response();

		if ( true === $should_validate_response ) {
			self::add_validation_error_sourcing();
			self::$is_validate_request = true;

			if ( &#039;1&#039; === (string) ini_get( &#039;display_errors&#039; ) ) {
				// Suppress the display of fatal errors that may arise during validation so that they will not be counted
				// as actual validation errors.
				ini_set( &#039;display_errors&#039;, 0 ); // phpcs:ignore WordPress.PHP.IniSet.display_errors_Blacklisted
			}
		} else {
			self::$is_validate_request = false;

			// Short-circuit validation requests that are unauthorized.
			if ( $should_validate_response instanceof WP_Error ) {
				wp_send_json(
					[
						&#039;code&#039;    =&gt; $should_validate_response-&gt;get_error_code(),
						&#039;message&#039; =&gt; $should_validate_response-&gt;get_error_message(),
					],
					401
				);
			}
		}
	}

	/**
	 * Add hooks for doing determining sources for validation errors during preprocessing/sanitizing.
	 */
	public static function add_validation_error_sourcing() {
		add_action( &#039;wp&#039;, [ __CLASS__, &#039;wrap_widget_callbacks&#039; ] );

		$int_min = defined( &#039;PHP_INT_MIN&#039; ) ? PHP_INT_MIN : ~PHP_INT_MAX; // phpcs:ignore PHPCompatibility.Constants.NewConstants.php_int_minFound
		add_filter( &#039;register_block_type_args&#039;, [ __CLASS__, &#039;wrap_block_callbacks&#039; ], $int_min );
		add_action( &#039;all&#039;, [ __CLASS__, &#039;wrap_hook_callbacks&#039; ] );
		$wrapped_filters = [ &#039;the_content&#039;, &#039;the_excerpt&#039; ];
		foreach ( $wrapped_filters as $wrapped_filter ) {
			add_filter( $wrapped_filter, [ __CLASS__, &#039;decorate_filter_source&#039; ], PHP_INT_MAX );
		}

		add_filter( &#039;do_shortcode_tag&#039;, [ __CLASS__, &#039;decorate_shortcode_source&#039; ], PHP_INT_MAX, 2 );
		add_filter( &#039;embed_oembed_html&#039;, [ __CLASS__, &#039;decorate_embed_source&#039; ], PHP_INT_MAX, 3 );

		// The `WP_Block_Type_Registry` class was added in WordPress 5.0.0. Because of that it sometimes caused issues
		// on the AMP Validated URL screen when on WordPress 4.9.
		if ( class_exists( &#039;WP_Block_Type_Registry&#039; ) ) {
			add_filter(
				&#039;the_content&#039;,
				[
					__CLASS__,
					&#039;add_block_source_comments&#039;,
				],
				8
			); // The do_blocks() function runs at priority 9.
		}

		add_filter( &#039;the_editor&#039;, [ __CLASS__, &#039;filter_the_editor_to_detect_sources&#039; ] );
	}

	/**
	 * Filter `the_editor` to detect the theme/plugin responsible for calling it `wp_editor()`.
	 *
	 * @since 2.2
	 * @see wp_editor()
	 *
	 * @param string $output Editor&#039;s HTML markup.
	 * @return string Editor&#039;s HTML markup (unchanged).
	 */
	public static function filter_the_editor_to_detect_sources( $output ) {
		$file_reflection = Services::get( &#039;dev_tools.file_reflection&#039; );

		// Find the first plugin/theme in the call stack.
		$backtrace = debug_backtrace( DEBUG_BACKTRACE_IGNORE_ARGS ); // phpcs:ignore WordPress.PHP.DevelopmentFunctions.error_log_debug_backtrace -- Only way to find theme/plugin responsible for calling.
		foreach ( $backtrace as $call ) {
			if (
				! empty( $call[&#039;function&#039;] )
				&amp;&amp;
				! empty( $call[&#039;file&#039;] )
				&amp;&amp;
				&#039;wp_editor&#039; === $call[&#039;function&#039;]
			) {
				$source = $file_reflection-&gt;get_file_source( $call[&#039;file&#039;] );
				if ( $source ) {
					self::$wp_editor_sources[] = $source;
				}
				break;
			}
		}

		return $output;
	}

	/**
	 * Handle save_post action to queue re-validation of the post on the frontend.
	 *
	 * This is intended to only apply to post edits made in the classic editor.
	 *
	 * @deprecated In 2.1 the classic editor block validation was removed.
	 * @codeCoverageIgnore
	 */
	public static function handle_save_post_prompting_validation() {
		_deprecated_function( __METHOD__, &#039;2.1&#039; );
	}

	/**
	 * Validate the posts pending frontend validation.
	 *
	 * @see AMP_Validation_Manager::handle_save_post_prompting_validation()
	 *
	 * @deprecated In 2.1 the classic editor block validation was removed.
	 * @codeCoverageIgnore
	 */
	public static function validate_queued_posts_on_frontend() {
		_deprecated_function( __METHOD__, &#039;2.1&#039; );
	}

	/**
	 * Map the amp_validate meta capability to the primitive manage_options capability.
	 *
	 * Using a meta capability allows a site to customize which users get access to perform validation.
	 *
	 * @param string[] $caps Array of the user&#039;s capabilities.
	 * @param string   $cap  Capability name.
	 * @return string[] Filtered primitive capabilities.
	 */
	public static function map_meta_cap( $caps, $cap ) {
		if ( self::VALIDATE_CAPABILITY === $cap ) {
			// Note that $caps most likely only contains a single item anyway, but only swapping out the one meta
			// capability with the primitive capability allows a site to add additional required capabilities.
			$position = array_search( $cap, $caps, true );
			if ( false !== $position ) {
				$caps[ $position ] = &#039;manage_options&#039;;
			}
		}
		return $caps;
	}

	/**
	 * Whether the user has the required capability to validate.
	 *
	 * Checks for permissions before validating.
	 *
	 * @param int|WP_User|null $user User to check for the capability. If null, the current user is used.
	 * @return boolean $has_cap Whether the current user has the capability.
	 */
	public static function has_cap( $user = null ) {
		if ( null === $user ) {
			$user = wp_get_current_user();
		}
		return user_can( $user, self::VALIDATE_CAPABILITY );
	}

	/**
	 * Add validation error.
	 *
	 * @param array $error Error info, especially code.
	 * @param array $data Additional data, including the node.
	 *
	 * @return bool Whether the validation error should result in sanitization.
	 */
	public static function add_validation_error( array $error, array $data = [] ) {
		$node    = null;
		$sources = null;

		if ( isset( $data[&#039;node&#039;] ) &amp;&amp; $data[&#039;node&#039;] instanceof DOMNode ) {
			$node = $data[&#039;node&#039;];
		}

		if ( self::is_validate_request() ) {
			if ( ! empty( $error[&#039;sources&#039;] ) ) {
				$sources = $error[&#039;sources&#039;];
			} elseif ( $node ) {
				$sources = self::locate_sources( $node );
			}
		}
		unset( $error[&#039;sources&#039;] );

		if ( ! isset( $error[&#039;code&#039;] ) ) {
			$error[&#039;code&#039;] = &#039;unknown&#039;;
		}

		/**
		 * Filters the validation error array.
		 *
		 * This allows plugins to add amend additional properties which can help with
		 * more accurately identifying a validation error beyond the name of the parent
		 * node and the element&#039;s attributes. The $sources are also omitted because
		 * these are only available during an explicit validation request and so they
		 * are not suitable for plugins to vary sanitization by. If looking to force a
		 * validation error to be ignored, use the &#039;amp_validation_error_sanitized&#039;
		 * filter instead of attempting to return an empty value with this filter (as
		 * that is not supported).
		 *
		 * @since 1.0
		 *
		 * @param array $error Validation error to be printed.
		 * @param array $context   {
		 *     Context data for validation error sanitization.
		 *
		 *     @type DOMNode $node Node for which the validation error is being reported. May be null.
		 * }
		 */
		$error = apply_filters( &#039;amp_validation_error&#039;, $error, compact( &#039;node&#039; ) );

		$sanitization = AMP_Validation_Error_Taxonomy::get_validation_error_sanitization( $error );
		$sanitized    = (
			AMP_Validation_Error_Taxonomy::VALIDATION_ERROR_NEW_ACCEPTED_STATUS === $sanitization[&#039;status&#039;]
			||
			AMP_Validation_Error_Taxonomy::VALIDATION_ERROR_ACK_ACCEPTED_STATUS === $sanitization[&#039;status&#039;]
		);

		/*
		 * Ignore validation errors which are forcibly sanitized by filter. This includes errors accepted via
		 * AMP_Validation_Error_Taxonomy::accept_validation_errors(), such as the acceptable_errors in core themes.
		 * This was introduced in &lt;https://github.com/ampproject/amp-wp/pull/1413&gt; to prevent forcibly-sanitized
		 * validation errors from being reported, to avoid noise and wasted storage. It was inadvertently
		 * reverted in de7b04b but then restored as part of &lt;https://github.com/ampproject/amp-wp/pull/1413&gt;.
		 */
		if ( $sanitized &amp;&amp; &#039;with_filter&#039; === $sanitization[&#039;forced&#039;] ) {
			return true;
		}

		// Add sources back into the $error for referencing later. @todo It may be cleaner to store sources separately to avoid having to re-remove later during storage.
		$error = array_merge( $error, compact( &#039;sources&#039; ) );

		self::$validation_results[] = compact( &#039;error&#039;, &#039;sanitized&#039; );
		return $sanitized;
	}

	/**
	 * Reset the stored removed nodes and attributes.
	 *
	 * After testing if the markup is valid,
	 * these static values will remain.
	 * So reset them in case another test is needed.
	 *
	 * @return void
	 */
	public static function reset_validation_results() {
		self::$validation_results              = [];
		self::$enqueued_style_sources          = [];
		self::$enqueued_script_sources         = [];
		self::$extra_script_sources            = [];
		self::$extra_style_sources             = [];
		self::$original_block_render_callbacks = [];
		self::$wp_editor_sources               = [];
	}

	/**
	 * Checks the AMP validity of the post content.
	 *
	 * If it&#039;s not valid AMP, it displays an error message above the &#039;Classic&#039; editor.
	 *
	 * This is essentially a PHP implementation of ampBlockValidation.handleValidationErrorsStateChange() in JS.
	 *
	 * @deprecated In 2.1 the classic editor block validation was removed.
	 * @codeCoverageIgnore
	 * @return void
	 */
	public static function print_edit_form_validation_status() {
		_deprecated_function( __METHOD__, &#039;2.1&#039; );
	}

	/**
	 * Get source start comment.
	 *
	 * @param array $source   Source data.
	 * @param bool  $is_start Whether the comment is the start or end.
	 * @return string HTML Comment.
	 */
	public static function get_source_comment( array $source, $is_start = true ) {
		unset( $source[&#039;reflection&#039;] );
		return sprintf(
			&#039;&lt;!--%samp-source-stack %s--&gt;&#039;,
			$is_start ? &#039;&#039; : &#039;/&#039;,
			str_replace( &#039;--&#039;, &#039;&#039;, wp_json_encode( $source ) )
		);
	}

	/**
	 * Parse source comment.
	 *
	 * @param DOMComment $comment Comment.
	 * @return array|null Parsed source or null if not a source comment.
	 */
	public static function parse_source_comment( DOMComment $comment ) {
		if ( ! preg_match( &#039;#^\s*(?P&lt;closing&gt;/)?amp-source-stack\s+(?P&lt;args&gt;{.+})\s*$#s&#039;, $comment-&gt;nodeValue, $matches ) ) {
			return null;
		}

		$source  = json_decode( $matches[&#039;args&#039;], true );
		$closing = ! empty( $matches[&#039;closing&#039;] );

		return compact( &#039;source&#039;, &#039;closing&#039; );
	}

	/**
	 * Recursively determine if a given dependency depends on another.
	 *
	 * @since 1.3
	 *
	 * @param WP_Dependencies $dependencies      Dependencies.
	 * @param string          $current_handle    Current handle.
	 * @param string          $dependency_handle Dependency handle.
	 * @return bool Whether the current handle is a dependency of the dependency handle.
	 */
	protected static function has_dependency( WP_Dependencies $dependencies, $current_handle, $dependency_handle ) {
		if ( $current_handle === $dependency_handle ) {
			return true;
		}
		if ( ! isset( $dependencies-&gt;registered[ $current_handle ] ) ) {
			return false;
		}
		foreach ( $dependencies-&gt;registered[ $current_handle ]-&gt;deps as $handle ) {
			if ( self::has_dependency( $dependencies, $handle, $dependency_handle ) ) {
				return true;
			}
		}
		return false;
	}

	/**
	 * Determine if a script element matches a given script handle.
	 *
	 * @param DOMElement $element       Element.
	 * @param string     $script_handle Script handle.
	 * @return bool
	 */
	protected static function is_matching_script( DOMElement $element, $script_handle ) {

		// Use the ID attribute which was added to printed scripts after WP ?.?.
		if ( $element-&gt;getAttribute( Attribute::ID ) === &quot;{$script_handle}-js&quot; ) {
			return true;
		}

		if ( ! isset( wp_scripts()-&gt;registered[ $script_handle ] ) ) {
			return false;
		}

		$script_dependency = wp_scripts()-&gt;registered[ $script_handle ];
		if ( empty( $script_dependency-&gt;src ) ) {
			return false;
		}

		// Script src attribute is haystack because includes protocol and may include query args (like ver).
		return false !== strpos(
			$element-&gt;getAttribute( &#039;src&#039; ),
			preg_replace( &#039;#^https?:(?=//)#&#039;, &#039;&#039;, $script_dependency-&gt;src )
		);
	}

	/**
	 * Walk back tree to find the open sources.
	 *
	 * @todo This method and others for sourcing could be moved to a separate class.
	 *
	 * @param DOMNode $node Node to look for.
	 * @return array[][] {
	 *       The data of the removed sources (theme, plugin, or mu-plugin).
	 *
	 *       @type string $name The name of the source.
	 *       @type string $type The type of the source.
	 * }
	 */
	public static function locate_sources( DOMNode $node ) {
		$dom      = Document::fromNode( $node );
		$comments = $dom-&gt;xpath-&gt;query( &#039;preceding::comment()[ starts-with( ., &quot;amp-source-stack&quot; ) or starts-with( ., &quot;/amp-source-stack&quot; ) ]&#039;, $node );
		$sources  = [];
		$matches  = [];

		foreach ( $comments as $comment ) {
			$parsed_comment = self::parse_source_comment( $comment );
			if ( ! $parsed_comment ) {
				continue;
			}
			if ( $parsed_comment[&#039;closing&#039;] ) {
				array_pop( $sources );
			} else {
				$sources[] = $parsed_comment[&#039;source&#039;];
			}
		}

		$is_enqueued_link = (
			$node instanceof DOMElement
			&amp;&amp;
			&#039;link&#039; === $node-&gt;nodeName
			&amp;&amp;
			preg_match( &#039;/(?P&lt;handle&gt;.+)-css$/&#039;, (string) $node-&gt;getAttribute( Attribute::ID ), $matches )
			&amp;&amp;
			wp_styles()-&gt;query( $matches[&#039;handle&#039;] )
		);
		if ( $is_enqueued_link ) {
			// Directly enqueued stylesheet.
			if ( isset( self::$enqueued_style_sources[ $matches[&#039;handle&#039;] ] ) ) {
				$sources = array_merge(
					self::$enqueued_style_sources[ $matches[&#039;handle&#039;] ],
					$sources
				);
			}

			// Stylesheet added as a dependency.
			foreach ( wp_styles()-&gt;done as $style_handle ) {
				if ( $matches[&#039;handle&#039;] !== $style_handle ) {
					continue;
				}

				foreach (
					self::find_done_dependent_handles( wp_styles(), $style_handle, array_keys( self::$enqueued_style_sources ) )
					as
					$enqueued_style_sources_handle
				) {
					$sources = array_merge(
						array_map(
							static function ( $enqueued_style_source ) use ( $style_handle ) {
								$enqueued_style_source[&#039;dependency_handle&#039;] = $style_handle;
								return $enqueued_style_source;
							},
							self::$enqueued_style_sources[ $enqueued_style_sources_handle ]
						),
						$sources
					);
				}
			}
		}

		$is_inline_style = (
			$node instanceof DOMElement
			&amp;&amp;
			&#039;style&#039; === $node-&gt;nodeName
			&amp;&amp;
			$node-&gt;firstChild instanceof DOMText
			&amp;&amp;
			$node-&gt;hasAttribute( Attribute::ID )
			&amp;&amp;
			preg_match( &#039;/^(?P&lt;handle&gt;.+)-inline-css$/&#039;, $node-&gt;getAttribute( Attribute::ID ), $matches )
			&amp;&amp;
			wp_styles()-&gt;query( $matches[&#039;handle&#039;] )
			&amp;&amp;
			isset( self::$extra_style_sources[ $matches[&#039;handle&#039;] ] )
		);
		if ( $is_inline_style ) {
			$text = $node-&gt;textContent;
			foreach ( self::$extra_style_sources[ $matches[&#039;handle&#039;] ] as $css =&gt; $extra_sources ) {
				if ( false !== strpos( $text, $css ) ) {
					$sources = array_merge(
						$sources,
						$extra_sources
					);
				}
			}
		}

		if ( $node instanceof DOMElement &amp;&amp; &#039;script&#039; === $node-&gt;nodeName ) {
			$enqueued_script_handles = array_intersect( wp_scripts()-&gt;done, array_keys( self::$enqueued_script_sources ) );

			if ( $node-&gt;hasAttribute( &#039;src&#039; ) ) {

				// External scripts, directly enqueued.
				foreach ( $enqueued_script_handles as $enqueued_script_handle ) {
					if ( ! self::is_matching_script( $node, $enqueued_script_handle ) ) {
						continue;
					}
					$sources = array_merge(
						self::$enqueued_script_sources[ $enqueued_script_handle ],
						$sources
					);
					break;
				}

				// External scripts, added as a dependency.
				foreach ( wp_scripts()-&gt;done as $script_handle ) {
					if ( ! self::is_matching_script( $node, $script_handle ) ) {
						continue;
					}

					foreach (
						self::find_done_dependent_handles( wp_scripts(), $script_handle, array_keys( self::$enqueued_script_sources ) )
						as
						$enqueued_script_sources_handle
					) {
						$sources = array_merge(
							array_map(
								static function ( $enqueued_script_source ) use ( $script_handle ) {
									$enqueued_script_source[&#039;dependency_handle&#039;] = $script_handle;
									return $enqueued_script_source;
								},
								self::$enqueued_script_sources[ $enqueued_script_sources_handle ]
							),
							$sources
						);
					}
				}
			} elseif ( $node-&gt;firstChild instanceof DOMText ) {
				$text = $node-&gt;textContent;

				$script_handle = null;
				$script_type   = null;
				if (
					$node-&gt;hasAttribute( Attribute::ID )
					&amp;&amp;
					preg_match( &#039;/^(.+)-js-(extra|after|before|translations)/&#039;, $node-&gt;getAttribute( Attribute::ID ), $matches )
				) {
					$script_handle = $matches[1];
					$script_type   = $matches[2];
				}

				if ( &#039;translations&#039; === $script_type ) {

					// Obtain sources for script translations.
					if ( isset( self::$enqueued_script_sources[ $script_handle ] ) ) {
						$sources = array_merge( $sources, self::$enqueued_script_sources[ $script_handle ] );
					}

					foreach (
						self::find_done_dependent_handles( wp_scripts(), $script_handle, array_keys( self::$enqueued_script_sources ) )
						as
						$enqueued_script_sources_handle
					) {
						$sources = array_merge(
							array_map(
								static function ( $enqueued_script_source ) use ( $script_handle ) {
									$enqueued_script_source[&#039;dependency_handle&#039;] = $script_handle;
									return $enqueued_script_source;
								},
								self::$enqueued_script_sources[ $enqueued_script_sources_handle ]
							),
							$sources
						);
					}
				} else {
					// Identify the inline script sources.
					foreach ( self::$extra_script_sources as $extra_data =&gt; $extra_sources ) {
						if ( false === strpos( $text, $extra_data ) ) {
							continue;
						}

						$has_non_core = false;
						foreach ( $extra_sources as $extra_source ) {
							if ( isset( $extra_source[&#039;type&#039;] ) &amp;&amp; &#039;core&#039; !== $extra_source[&#039;type&#039;] ) {
								$has_non_core = true;
								break;
							}
						}

						if ( $has_non_core ) {
							$sources = array_merge(
								$sources,
								$extra_sources
							);
						} else {
							if ( isset( self::$enqueued_script_sources[ $script_handle ] ) ) {
								$sources = array_merge( $sources, self::$enqueued_script_sources[ $script_handle ] );
							}

							foreach (
								self::find_done_dependent_handles( wp_scripts(), $script_handle, array_keys( self::$enqueued_script_sources ) )
								as
								$enqueued_script_sources_handle
							) {
								$sources = array_merge(
									array_map(
										static function ( $enqueued_script_source ) use ( $script_handle ) {
											$enqueued_script_source[&#039;dependency_handle&#039;] = $script_handle;
											return $enqueued_script_source;
										},
										self::$enqueued_script_sources[ $enqueued_script_sources_handle ]
									),
									$sources
								);
							}
						}
					}
				}

				// Add indirect sources for inline scripts added by wp_editor().
				foreach ( $sources as $source ) {
					if ( isset( $source[&#039;function&#039;] ) &amp;&amp; &#039;_WP_Editors::editor_js&#039; === $source[&#039;function&#039;] ) {
						$sources = array_merge( $sources, self::$wp_editor_sources );
					}
				}
			}
		}

		$sources = array_values( array_unique( $sources, SORT_REGULAR ) );

		return $sources;
	}

	/**
	 * Find dependent handles that have been printed.
	 *
	 * @param WP_Dependencies $dependencies Dependencies.
	 * @param string          $handle Handle.
	 * @param string[]        $enqueued_handles Enqueued handles.
	 * @return string[] Found handles.
	 */
	private static function find_done_dependent_handles( WP_Dependencies $dependencies, $handle, $enqueued_handles ) {
		$dependent_handles = [];
		foreach ( $enqueued_handles as $enqueued_handle ) {
			if (
				$enqueued_handle !== $handle
				&amp;&amp;
				$dependencies-&gt;query( $enqueued_handle, &#039;done&#039; )
				&amp;&amp;
				self::has_dependency( $dependencies, $enqueued_handle, $handle )
			) {
				$dependent_handles[] = $enqueued_handle;
			}
		}
		return $dependent_handles;
	}

	/**
	 * Add block source comments.
	 *
	 * @param string $content Content prior to blocks being processed.
	 * @return string Content with source comments added.
	 */
	public static function add_block_source_comments( $content ) {
		self::$block_content_index = 0;

		$start_block_pattern = implode(
			&#039;&#039;,
			[
				&#039;#&lt;!--\s+&#039;,
				&#039;(?P&lt;closing&gt;/)?&#039;,
				&#039;wp:(?P&lt;name&gt;\S+)&#039;,
				&#039;(?:\s+(?P&lt;attributes&gt;\{.*?\}))?&#039;,
				&#039;\s+(?P&lt;self_closing&gt;\/)?&#039;,
				&#039;--&gt;#s&#039;,
			]
		);

		return preg_replace_callback(
			$start_block_pattern,
			[ __CLASS__, &#039;handle_block_source_comment_replacement&#039; ],
			$content
		);
	}

	/**
	 * Handle block source comment replacement.
	 *
	 * @see \AMP_Validation_Manager::add_block_source_comments()
	 *
	 * @param array $matches Matches.
	 *
	 * @return string Replaced.
	 */
	protected static function handle_block_source_comment_replacement( $matches ) {
		$replaced = $matches[0];

		// Obtain source information for block.
		$source = [
			&#039;block_name&#039; =&gt; $matches[&#039;name&#039;],
			&#039;post_id&#039;    =&gt; get_the_ID(),
		];

		if ( empty( $matches[&#039;closing&#039;] ) ) {
			$source[&#039;block_content_index&#039;] = self::$block_content_index;
			++self::$block_content_index;
		}

		// Make implicit core namespace explicit.
		$is_implicit_core_namespace = ( false === strpos( $source[&#039;block_name&#039;], &#039;/&#039; ) );
		$source[&#039;block_name&#039;]       = $is_implicit_core_namespace ? &#039;core/&#039; . $source[&#039;block_name&#039;] : $source[&#039;block_name&#039;];

		if ( ! empty( $matches[&#039;attributes&#039;] ) ) {
			$source[&#039;block_attrs&#039;] = json_decode( $matches[&#039;attributes&#039;] );
		}
		$block_type = WP_Block_Type_Registry::get_instance()-&gt;get_registered( $source[&#039;block_name&#039;] );
		if ( $block_type &amp;&amp; $block_type-&gt;is_dynamic() ) {
			$render_callback = $block_type-&gt;render_callback;

			// Access the underlying callback which was wrapped by ::wrap_block_callbacks() below.
			while ( $render_callback instanceof AMP_Validation_Callback_Wrapper ) {
				$render_callback = $render_callback-&gt;get_callback_function();
			}

			$callback_reflection = Services::get( &#039;dev_tools.callback_reflection&#039; );
			$callback_source     = $callback_reflection-&gt;get_source( $render_callback );

			// Handle special case to undo the wrapping that Gutenberg does in gutenberg_inject_default_block_context().
			if (
				$callback_source
				&amp;&amp;
				&#039;plugin&#039; === $callback_source[&#039;type&#039;]
				&amp;&amp;
				&#039;gutenberg&#039; === $callback_source[&#039;name&#039;]
				&amp;&amp;
				array_key_exists( $source[&#039;block_name&#039;], self::$original_block_render_callbacks )
			) {
				$callback_source = $callback_reflection-&gt;get_source( self::$original_block_render_callbacks[ $source[&#039;block_name&#039;] ] );
			}

			if ( $callback_source ) {
				$source = array_merge(
					$source,
					$callback_source
				);
			}
		}

		if ( ! empty( $matches[&#039;closing&#039;] ) ) {
			$replaced .= self::get_source_comment( $source, false );
		} else {
			$replaced = self::get_source_comment( $source, true ) . $replaced;
			if ( ! empty( $matches[&#039;self_closing&#039;] ) ) {
				unset( $source[&#039;block_content_index&#039;] );
				$replaced .= self::get_source_comment( $source, false );
			}
		}
		return $replaced;
	}

	/**
	 * Wrap callbacks for registered blocks to keep track of queued assets and the source for anything printed for validation.
	 *
	 * @param array $args Array of arguments for registering a block type.
	 *
	 * @return array Array of arguments for registering a block type.
	 */
	public static function wrap_block_callbacks( $args ) {

		if ( ! isset( $args[&#039;render_callback&#039;] ) || ! is_callable( $args[&#039;render_callback&#039;] ) ) {
			return $args;
		}

		$callback_reflection = Services::get( &#039;dev_tools.callback_reflection&#039; );
		$source              = $callback_reflection-&gt;get_source( $args[&#039;render_callback&#039;] );

		if ( ! $source ) {
			return $args;
		}

		unset( $source[&#039;reflection&#039;] ); // Omit from stored source.
		$original_function = $args[&#039;render_callback&#039;];

		if ( isset( $args[&#039;name&#039;] ) ) {
			self::$original_block_render_callbacks[ $args[&#039;name&#039;] ] = $original_function;
		}

		$args[&#039;render_callback&#039;] = new AMP_Validation_Callback_Wrapper(
			[
				&#039;function&#039;      =&gt; $original_function,
				&#039;source&#039;        =&gt; $source,
				&#039;accepted_args&#039; =&gt; 3, // The three args passed to render_callback are $attributes, $content, and $block.
			]
		);

		return $args;
	}

	/**
	 * Wrap callbacks for registered widgets to keep track of queued assets and the source for anything printed for validation.
	 *
	 * @return void
	 * @global array $wp_registered_widgets
	 */
	public static function wrap_widget_callbacks() {
		global $wp_registered_widgets;
		$callback_reflection = Services::get( &#039;dev_tools.callback_reflection&#039; );
		foreach ( $wp_registered_widgets as $widget_id =&gt; &amp;$registered_widget ) {
			$source = $callback_reflection-&gt;get_source( $registered_widget[&#039;callback&#039;] );
			if ( ! $source ) {
				continue;
			}
			$source[&#039;widget_id&#039;] = $widget_id;
			unset( $source[&#039;reflection&#039;] ); // Omit from stored source.

			$function      = $registered_widget[&#039;callback&#039;];
			$accepted_args = 2; // For the $instance and $args arguments.
			$callback      = compact( &#039;function&#039;, &#039;accepted_args&#039;, &#039;source&#039; );

			$registered_widget[&#039;callback&#039;] = new AMP_Validation_Callback_Wrapper( $callback );
		}
	}

	/**
	 * Wrap filter/action callback functions for a given hook.
	 *
	 * Wrapped callback functions are reset to their original functions after invocation.
	 * This runs at the &#039;all&#039; action. The shutdown hook is excluded.
	 *
	 * @global WP_Hook[] $wp_filter
	 * @param string $hook Hook name for action or filter.
	 * @return void
	 */
	public static function wrap_hook_callbacks( $hook ) {
		global $wp_filter;

		if ( ! isset( $wp_filter[ $hook ] ) || &#039;shutdown&#039; === $hook ) {
			return;
		}

		$callback_reflection = Services::get( &#039;dev_tools.callback_reflection&#039; );

		self::$current_hook_source_stack[ $hook ] = [];
		foreach ( $wp_filter[ $hook ]-&gt;callbacks as $priority =&gt; &amp;$callbacks ) {
			foreach ( $callbacks as &amp;$callback ) {
				$source = $callback_reflection-&gt;get_source( $callback[&#039;function&#039;] );
				if ( ! $source ) {
					continue;
				}

				// Skip considering ourselves.
				if ( &#039;AMP_Validation_Manager::add_block_source_comments&#039; === $source[&#039;function&#039;] ) {
					continue;
				}

				$indirect_sources = [];
				if ( &#039;_WP_Editors::enqueue_scripts&#039; === $source[&#039;function&#039;] ) {
					$indirect_sources = self::$wp_editor_sources;
				}

				/**
				 * Reflection.
				 *
				 * @var ReflectionFunction|ReflectionMethod $reflection
				 */
				$reflection = $source[&#039;reflection&#039;];
				unset( $source[&#039;reflection&#039;] ); // Omit from stored source.

				// Add hook to stack for decorate_filter_source to read from.
				self::$current_hook_source_stack[ $hook ][] = $source;

				/*
				 * Wrapped callbacks cause PHP warnings when the wrapped function has arguments passed by reference.
				 * We have a special case to support functions that have the first argument passed by reference, namely
				 * wp_default_scripts() and wp_default_styles(). But other configurations are bypassed.
				 */
				$passed_by_ref = self::has_parameters_passed_by_reference( $reflection );
				if ( $passed_by_ref &gt; 1 ) {
					continue;
				}

				$source[&#039;hook&#039;]     = $hook;
				$source[&#039;priority&#039;] = $priority;
				$original_function  = $callback[&#039;function&#039;];

				$wrapped_callback = new AMP_Validation_Callback_Wrapper(
					array_merge(
						$callback,
						compact( &#039;priority&#039;, &#039;source&#039;, &#039;indirect_sources&#039; )
					),
					static function () use ( &amp;$callback, $original_function ) {
						// Restore the original callback function in case other plugins are introspecting filters.
						// This logic runs immediately before the original function is actually invoked.
						$callback[&#039;function&#039;] = $original_function;
					}
				);

				if ( 1 === $passed_by_ref ) {
					$callback[&#039;function&#039;] = [ $wrapped_callback, &#039;invoke_with_first_ref_arg&#039; ];
				} else {
					$callback[&#039;function&#039;] = $wrapped_callback;
				}
			}
		}
	}

	/**
	 * Determine whether the given reflection method/function has params passed by reference.
	 *
	 * @since 0.7
	 * @param ReflectionFunction|ReflectionMethod $reflection Reflection.
	 * @return int Whether there are parameters passed by reference, where 0 means none were passed, 1 means the first was passed, and 2 means some other configuration.
	 */
	protected static function has_parameters_passed_by_reference( $reflection ) {
		$status = 0;
		foreach ( $reflection-&gt;getParameters() as $i =&gt; $parameter ) {
			if ( $parameter-&gt;isPassedByReference() ) {
				if ( 0 === $i ) {
					$status = 1;
				} else {
					$status = 2;
					break;
				}
			}
		}
		return $status;
	}

	/**
	 * Filters the output created by a shortcode callback.
	 *
	 * @since 0.7
	 *
	 * @param string $output Shortcode output.
	 * @param string $tag    Shortcode name.
	 * @return string Output.
	 * @global array $shortcode_tags
	 */
	public static function decorate_shortcode_source( $output, $tag ) {
		global $shortcode_tags;
		if ( ! isset( $shortcode_tags[ $tag ] ) ) {
			return $output;
		}

		$callback_reflection = Services::get( &#039;dev_tools.callback_reflection&#039; );

		$source = $callback_reflection-&gt;get_source( $shortcode_tags[ $tag ] );
		if ( empty( $source ) ) {
			return $output;
		}
		$source[&#039;shortcode&#039;] = $tag;

		$output = implode(
			&#039;&#039;,
			[
				self::get_source_comment( $source, true ),
				$output,
				self::get_source_comment( $source, false ),
			]
		);
		return $output;
	}

	/**
	 * Filters the output created by embeds.
	 *
	 * @since 1.0
	 *
	 * @param string $output Embed output.
	 * @param string $url    URL.
	 * @param array  $attr   Attributes.
	 * @return string Output.
	 */
	public static function decorate_embed_source( $output, $url, $attr ) {
		$source = [
			&#039;embed&#039; =&gt; $url,
			&#039;attr&#039;  =&gt; $attr,
		];
		return implode(
			&#039;&#039;,
			[
				self::get_source_comment( $source, true ),
				trim( $output ),
				self::get_source_comment( $source, false ),
			]
		);
	}

	/**
	 * Wraps output of a filter to add source stack comments.
	 *
	 * @todo Duplicate with AMP_Validation_Manager::wrap_buffer_with_source_comments()?
	 * @param string $value Value.
	 * @return string Value wrapped in source comments.
	 */
	public static function decorate_filter_source( $value ) {

		// Abort if the output is not a string and it doesn&#039;t contain any HTML tags.
		if ( ! is_string( $value ) || ! preg_match( &#039;/&lt;.+?&gt;/s&#039;, $value ) ) {
			return $value;
		}

		$post   = get_post();
		$source = [
			&#039;hook&#039;   =&gt; current_filter(),
			&#039;filter&#039; =&gt; true,
		];
		if ( $post ) {
			$source[&#039;post_id&#039;]   = $post-&gt;ID;
			$source[&#039;post_type&#039;] = $post-&gt;post_type;
		}
		if ( isset( self::$current_hook_source_stack[ current_filter() ] ) ) {
			$sources = self::$current_hook_source_stack[ current_filter() ];
			array_pop( $sources ); // Remove self.
			$source[&#039;sources&#039;] = $sources;
		}
		return implode(
			&#039;&#039;,
			[
				self::get_source_comment( $source, true ),
				$value,
				self::get_source_comment( $source, false ),
			]
		);
	}

	/**
	 * Gets the plugin or theme of the callback, if one exists.
	 *
	 * @deprecated 2.0.2 Use \AmpProject\AmpWP\DevTools\CallbackReflection::get_source().
	 * @codeCoverageIgnore
	 *
	 * @param string|array|callable $callback The callback for which to get the plugin.
	 * @return array|null {
	 *     The source data.
	 *
	 *     @type string $type     Source type (core, plugin, mu-plugin, or theme).
	 *     @type string $name     Source name.
	 *     @type string $file     Relative file path based on the type.
	 *     @type string $function Normalized function name.
	 *     @type ReflectionMethod|ReflectionFunction $reflection Reflection.
	 * }
	 */
	public static function get_source( $callback ) {
		_deprecated_function(
			__METHOD__,
			&#039;2.0.2&#039;,
			&#039;\AmpProject\AmpWP\DevTools\CallbackReflection::get_source&#039;
		);
		return Services::get( &#039;dev_tools.callback_reflection&#039; )
			-&gt;get_source( $callback );
	}

	/**
	 * Check whether or not output buffering is currently possible.
	 *
	 * This is to guard against a fatal error: &quot;ob_start(): Cannot use output buffering in output buffering display handlers&quot;.
	 *
	 * @return bool Whether output buffering is allowed.
	 */
	public static function can_output_buffer() {

		// Output buffering for validation can only be done while overall output buffering is being done for the response.
		if ( ! AMP_Theme_Support::is_output_buffering() ) {
			return false;
		}

		// Abort when in shutdown since output has finished, when we&#039;re likely in the overall output buffering display handler.
		if ( did_action( &#039;shutdown&#039; ) ) {
			return false;
		}

		// Check if any functions in call stack are output buffering display handlers.
		$called_functions = [];
		$backtrace        = debug_backtrace( DEBUG_BACKTRACE_IGNORE_ARGS ); // phpcs:ignore WordPress.PHP.DevelopmentFunctions.error_log_debug_backtrace -- Only way to find out if we are in a buffering display handler.
		foreach ( $backtrace as $call_stack ) {
			if ( &#039;{closure}&#039; === $call_stack[&#039;function&#039;] ) { // TODO: This may not be the right format for PHP 8.4.
				$called_functions[] = &#039;Closure::__invoke&#039;;
			} elseif ( isset( $call_stack[&#039;class&#039;] ) ) {
				$called_functions[] = sprintf( &#039;%s::%s&#039;, $call_stack[&#039;class&#039;], $call_stack[&#039;function&#039;] );
			} else {
				$called_functions[] = $call_stack[&#039;function&#039;];
			}
		}
		return 0 === count( array_intersect( ob_list_handlers(), $called_functions ) );
	}

	/**
	 * Wraps a callback in comments if it outputs markup.
	 *
	 * If the sanitizer removes markup,
	 * this indicates which plugin it was from.
	 * The call_user_func_array() logic is mainly copied from WP_Hook:apply_filters().
	 *
	 * @deprecated No longer used as of 2.2.1.
	 * @codeCoverageIgnore
	 *
	 * @param array $callback {
	 *     The callback data.
	 *
	 *     @type callable $function
	 *     @type int      $accepted_args
	 *     @type array    $source
	 * }
	 * @return AMP_Validation_Callback_Wrapper $wrapped_callback The callback, wrapped in comments.
	 */
	public static function wrapped_callback( $callback ) {
		return new AMP_Validation_Callback_Wrapper( $callback );
	}

	/**
	 * Wrap output buffer with source comments.
	 *
	 * A key reason for why this is a method and not a closure is so that
	 * the can_output_buffer method will be able to identify it by name.
	 *
	 * @since 0.7
	 * @todo Is duplicate of \AMP_Validation_Manager::decorate_filter_source()?
	 *
	 * @param string $output Output buffer.
	 * @return string Output buffer conditionally wrapped with source comments.
	 */
	public static function wrap_buffer_with_source_comments( $output ) {
		if ( empty( self::$hook_source_stack ) ) {
			return $output;
		}

		$source = self::$hook_source_stack[ count( self::$hook_source_stack ) - 1 ];

		// Wrap output that contains HTML tags (as opposed to actions that trigger in HTML attributes).
		if ( ! empty( $output ) &amp;&amp; preg_match( &#039;/&lt;.+?&gt;/s&#039;, $output ) ) {
			$output = implode(
				&#039;&#039;,
				[
					self::get_source_comment( $source, true ),
					$output,
					self::get_source_comment( $source, false ),
				]
			);
		}
		return $output;
	}

	/**
	 * Get nonce for performing amp_validate request.
	 *
	 * The returned nonce is irrespective of the authenticated user.
	 *
	 * @return string Nonce.
	 */
	public static function get_amp_validate_nonce() {
		return wp_hash( self::VALIDATE_QUERY_VAR . wp_nonce_tick(), &#039;nonce&#039; );
	}

	/**
	 * Whether the request is to validate URL for validation errors.
	 *
	 * All AMP responses get validated, but when the amp_validate query parameter is present, then the source information
	 * for each validation error is captured and the validation results are returned as JSON instead of the AMP HTML page.
	 *
	 * @return bool|WP_Error Whether to validate. False is returned if it is not a validate request. WP_Error returned
	 *                       if unauthenticated, unauthorized, and/or invalid nonce supplied. True returned if
	 *                       validate response should be served.
	 */
	public static function should_validate_response() {
		$args = self::get_validate_request_args();

		if ( null === $args[ self::VALIDATE_QUERY_VAR_NONCE ] ) {
			return false;
		}

		if ( ! hash_equals( self::get_amp_validate_nonce(), $args[ self::VALIDATE_QUERY_VAR_NONCE ] ) ) {
			return new WP_Error(
				&#039;http_request_failed&#039;,
				__( &#039;Nonce authentication failed.&#039;, &#039;amp&#039; )
			);
		}

		return true;
	}

	/**
	 * Get response data for a validate request.
	 *
	 * @see AMP_Content_Sanitizer::sanitize_document()
	 *
	 * @param array $sanitization_results {
	 *     Results of sanitizing a document, as returned by AMP_Content_Sanitizer::sanitize_document().
	 *
	 *     @type array                $scripts     Scripts.
	 *     @type array                $stylesheets Stylesheets.
	 *     @type AMP_Base_Sanitizer[] $sanitizers  Sanitizers.
	 * }
	 * @return array Validate response data.
	 */
	public static function get_validate_response_data( $sanitization_results ) {
		$data = [
			&#039;results&#039;        =&gt; self::$validation_results,
			&#039;queried_object&#039; =&gt; null,
			&#039;url&#039;            =&gt; amp_get_current_url(),
		];

		$queried_object = get_queried_object();
		if ( $queried_object ) {
			$data[&#039;queried_object&#039;] = [];
			$queried_object_id      = get_queried_object_id();
			if ( $queried_object_id ) {
				$data[&#039;queried_object&#039;][&#039;id&#039;] = $queried_object_id;
			}
			if ( $queried_object instanceof WP_Post ) {
				$data[&#039;queried_object&#039;][&#039;type&#039;] = &#039;post&#039;;
			} elseif ( $queried_object instanceof WP_Term ) {
				$data[&#039;queried_object&#039;][&#039;type&#039;] = &#039;term&#039;;
			} elseif ( $queried_object instanceof WP_User ) {
				$data[&#039;queried_object&#039;][&#039;type&#039;] = &#039;user&#039;;
			} elseif ( $queried_object instanceof WP_Post_Type ) {
				$data[&#039;queried_object&#039;][&#039;type&#039;] = &#039;post_type&#039;;
			}
		}

		/**
		 * Sanitizers
		 *
		 * @var AMP_Base_Sanitizer[] $sanitizers
		 */
		$sanitizers = $sanitization_results[&#039;sanitizers&#039;];
		foreach ( $sanitizers as $class_name =&gt; $sanitizer ) {
			$sanitizer_data = $sanitizer-&gt;get_validate_response_data();

			$conflicting_keys = array_intersect( array_keys( $sanitizer_data ), array_keys( $data ) );
			if ( ! empty( $conflicting_keys ) ) {
				_doing_it_wrong(
					esc_html( &quot;$class_name::get_validate_response_data&quot; ),
					esc_html( &#039;Method is returning array with conflicting keys: &#039; . implode( &#039;, &#039;, $conflicting_keys ) ),
					&#039;1.5&#039;
				);
			} else {
				$data = array_merge( $data, $sanitizer_data );
			}
		}

		return $data;
	}

	/**
	 * Remove source stack comments which appear inside of script and style tags.
	 *
	 * HTML comments that appear inside of script and style elements get parsed as text content. AMP does not allow
	 * such HTML comments to appear inside of CDATA, resulting in validation errors to be emitted when validating a
	 * page that happens to have source stack comments output when generating JSON data (e.g. All in One SEO).
	 * Additionally, when source stack comments are output inside of style elements the result can either be CSS
	 * parse errors or incorrect stylesheet sizes being reported due to the presence of the source stack comments.
	 * So to prevent these issues from occurring, the source stack comments need to be removed from the document prior
	 * to sanitizing.
	 *
	 * @since 1.5
	 *
	 * @param Document $dom Document.
	 */
	public static function remove_illegal_source_stack_comments( Document $dom ) {
		/**
		 * Script element.
		 *
		 * @var DOMText $text
		 */
		foreach ( $dom-&gt;xpath-&gt;query( &#039;//text()[ contains( ., &quot;&lt;!--amp-source-stack&quot; ) ][ parent::script or parent::style ]&#039; ) as $text ) {
			$text-&gt;nodeValue = preg_replace( &#039;#&lt;!--/?amp-source-stack.*?--&gt;#s&#039;, &#039;&#039;, $text-&gt;nodeValue );
		}
	}

	/**
	 * Send validate response.
	 *
	 * @since 2.2
	 * @see AMP_Theme_Support::prepare_response()
	 *
	 * @param array      $sanitization_results Sanitization results.
	 * @param int        $status_code          Status code.
	 * @param array|null $last_error           Last error.
	 * @return string JSON.
	 */
	public static function send_validate_response( $sanitization_results, $status_code, $last_error ) {
		status_header( 200 );
		if ( ! headers_sent() ) {
			header( &#039;Content-Type: application/json; charset=utf-8&#039; );
		}
		$data = [
			&#039;http_status_code&#039; =&gt; $status_code,
			&#039;php_fatal_error&#039;  =&gt; false,
		];
		if ( $last_error &amp;&amp; in_array( $last_error[&#039;type&#039;], [ E_ERROR, E_RECOVERABLE_ERROR, E_CORE_ERROR, E_COMPILE_ERROR, E_USER_ERROR, E_PARSE ], true ) ) {
			$data[&#039;php_fatal_error&#039;] = $last_error;
		}
		$data = array_merge( $data, self::get_validate_response_data( $sanitization_results ) );

		$args = self::get_validate_request_args();

		$data[&#039;revalidated&#039;] = true;

		if ( $args[ self::VALIDATE_QUERY_VAR_CACHE ] ) {
			$validation_errors = wp_list_pluck( $data[&#039;results&#039;], &#039;error&#039; );

			$validated_url_post_id = AMP_Validated_URL_Post_Type::store_validation_errors(
				$validation_errors,
				amp_get_current_url(),
				$data
			);
			if ( is_wp_error( $validated_url_post_id ) ) {
				status_header( 500 );
				return wp_json_encode(
					[
						&#039;code&#039;    =&gt; $validated_url_post_id-&gt;get_error_code(),
						&#039;message&#039; =&gt; $validated_url_post_id-&gt;get_error_message(),
					]
				);
			} else {
				status_header( 201 );
				$data[&#039;validated_url_post&#039;] = [
					&#039;id&#039;        =&gt; $validated_url_post_id,
					&#039;edit_link&#039; =&gt; get_edit_post_link( $validated_url_post_id, &#039;raw&#039; ),
				];
			}
		}

		if ( $args[ self::VALIDATE_QUERY_VAR_OMIT_STYLESHEETS ] ) {
			unset( $data[&#039;stylesheets&#039;] );
		}

		$data[&#039;url&#039;] = remove_query_arg( self::VALIDATE_QUERY_VAR, $data[&#039;url&#039;] );

		return wp_json_encode( $data, JSON_UNESCAPED_SLASHES );
	}

	/**
	 * Send cached validate response if it is requested and available.
	 *
	 * When a validate request is made with the `amp_validate[cached_if_fresh]=true` query parameter, before a page
	 * begins rendering a check is made for whether there is already an `amp_validated_url` post for the current URL.
	 * If there is, and the post is not stale, then the previous results are returned without re-rendering page and
	 * obtaining the validation data.
	 */
	public static function maybe_send_cached_validate_response() {
		if ( ! self::is_validate_request() ) {
			return;
		}
		$args = self::get_validate_request_args();

		if ( ! $args[ self::VALIDATE_QUERY_VAR_CACHED_IF_FRESH ] ) {
			return;
		}

		$post = AMP_Validated_URL_Post_Type::get_invalid_url_post( amp_get_current_url() );
		if ( ! ( $post instanceof WP_Post ) ) {
			return;
		}

		$staleness = AMP_Validated_URL_Post_Type::get_post_staleness( $post );
		if ( count( $staleness ) &gt; 0 ) {
			return;
		}

		$response = [
			&#039;http_status_code&#039;   =&gt; 200, // Note: This is not currently cached in postmeta.
			&#039;php_fatal_error&#039;    =&gt; false,
			&#039;results&#039;            =&gt; [],
			&#039;queried_object&#039;     =&gt; null,
			&#039;url&#039;                =&gt; null,
			&#039;revalidated&#039;        =&gt; false, // Since cached was used.
			&#039;validated_url_post&#039; =&gt; [
				&#039;id&#039;        =&gt; $post-&gt;ID,
				&#039;edit_link&#039; =&gt; get_edit_post_link( $post-&gt;ID, &#039;raw&#039; ),
			],
		];

		if ( ! $args[ self::VALIDATE_QUERY_VAR_OMIT_STYLESHEETS ] ) {
			$stylesheets = get_post_meta( $post-&gt;ID, AMP_Validated_URL_Post_Type::STYLESHEETS_POST_META_KEY, true );
			if ( $stylesheets ) {
				$response[&#039;stylesheets&#039;] = json_decode( $stylesheets, true );
			}
		}

		$stored_validation_errors = json_decode( $post-&gt;post_content, true );
		if ( is_array( $stored_validation_errors ) ) {
			$response[&#039;results&#039;] = array_map(
				static function ( $stored_validation_error ) {
					$error     = $stored_validation_error[&#039;data&#039;];
					$sanitized = AMP_Validation_Error_Taxonomy::is_validation_error_sanitized( $error );
					return compact( &#039;error&#039;, &#039;sanitized&#039; );
				},
				$stored_validation_errors
			);
		}

		$queried_object = get_post_meta( $post-&gt;ID, AMP_Validated_URL_Post_Type::QUERIED_OBJECT_POST_META_KEY, true );
		if ( $queried_object ) {
			$response[&#039;queried_object&#039;] = $queried_object;
		}

		$php_fatal_error = get_post_meta( $post-&gt;ID, AMP_Validated_URL_Post_Type::PHP_FATAL_ERROR_POST_META_KEY, true );
		if ( $php_fatal_error ) {
			$response[&#039;php_fatal_error&#039;] = $php_fatal_error;
		}

		$response[&#039;url&#039;] = AMP_Validated_URL_Post_Type::get_url_from_post( $post );

		wp_send_json( $response, 200, JSON_UNESCAPED_SLASHES );
	}

	/**
	 * Finalize validation.
	 *
	 * @see AMP_Validation_Manager::add_admin_bar_menu_items()
	 *
	 * @param Document $dom Document.
	 * @return bool Whether the document should be displayed to the user.
	 */
	public static function finalize_validation( Document $dom ) {
		$total_count      = 0;
		$kept_count       = 0;
		$unreviewed_count = 0;
		foreach ( self::$validation_results as $validation_result ) {
			$sanitization = AMP_Validation_Error_Taxonomy::get_validation_error_sanitization( $validation_result[&#039;error&#039;] );
			if ( ! ( (int) $sanitization[&#039;status&#039;] &amp; AMP_Validation_Error_Taxonomy::ACCEPTED_VALIDATION_ERROR_BIT_MASK ) ) {
				++$kept_count;
			}
			if ( ! ( (int) $sanitization[&#039;status&#039;] &amp; AMP_Validation_Error_Taxonomy::ACKNOWLEDGED_VALIDATION_ERROR_BIT_MASK ) ) {
				++$unreviewed_count;
			}
			++$total_count;
		}

		/*
		 * Override AMP status in admin bar set in \AMP_Validation_Manager::add_admin_bar_menu_items()
		 * when there are validation errors which have not been explicitly accepted.
		 */
		if ( is_admin_bar_showing() &amp;&amp; self::$amp_admin_bar_item_added &amp;&amp; $total_count &gt; 0 ) {
			self::update_admin_bar_item( $dom, $total_count, $kept_count, $unreviewed_count );
		}

		// If no invalid markup is kept, then the page should definitely be displayed to the user.
		if ( 0 === $kept_count ) {
			return true;
		}

		// When overrides are present, go ahead and display to the user.
		if ( ! empty( self::$validation_error_status_overrides ) ) {
			return true;
		}

		$sandboxing_level = amp_get_sandboxing_level();

		/*
		 * In AMP-first, documents with invalid AMP markup can still be served. The amp attribute will be omitted in
		 * order to prevent GSC from complaining about a validation error already surfaced inside of WordPress.
		 * This is intended to not serve dirty AMP, but rather a non-AMP document (intentionally not valid AMP) that
		 * contains the AMP runtime and AMP components.
		 *
		 * Otherwise, if in Paired AMP then redirect to the non-AMP version if the current user isn&#039;t an user who
		 * can manage validation error statuses (access developer tools) and change the AMP options for the template
		 * mode. Such users should be able to see kept invalid markup on the AMP page even though it is invalid.
		 *
		 * Also, if sandboxing is not set to strict mode, then the page should be displayed to the user.
		 */
		if ( amp_is_canonical() || ( 1 === $sandboxing_level || 2 === $sandboxing_level ) ) {
			return true;
		}

		// Otherwise, since it is in a paired mode, only allow showing the dirty AMP page if the user is authorized.
		// If not, normally the result is redirection to the non-AMP version.
		return self::has_cap() || is_customize_preview();
	}

	/**
	 * Override AMP status in admin bar set in \AMP_Validation_Manager::add_admin_bar_menu_items()
	 * when there are validation errors which have not been explicitly accepted.
	 *
	 * @param Document $dom              Document.
	 * @param int      $total_count      Total count of validation errors (more than 0).
	 * @param int      $kept_count       Count of validation errors with invalid markup kept.
	 * @param int      $unreviewed_count Count of unreviewed validation errors.
	 */
	private static function update_admin_bar_item( Document $dom, $total_count, $kept_count, $unreviewed_count ) {
		$parent_menu_item = $dom-&gt;getElementById( &#039;wp-admin-bar-amp&#039; );
		if ( ! $parent_menu_item instanceof DOMElement ) {
			return;
		}

		$parent_menu_link = $dom-&gt;xpath-&gt;query( &#039;./a[ @href ]&#039;, $parent_menu_item )-&gt;item( 0 );
		$admin_bar_icon   = $dom-&gt;xpath-&gt;query( &#039;./span[ @id = &quot;amp-admin-bar-item-status-icon&quot; ]&#039;, $parent_menu_link )-&gt;item( 0 );
		$validate_link    = $dom-&gt;xpath-&gt;query( &#039;.//li[ @id = &quot;wp-admin-bar-amp-validity&quot; ]/a[ @href ]&#039;, $parent_menu_item )-&gt;item( 0 );
		if ( ! $parent_menu_link instanceof DOMElement || ! $admin_bar_icon instanceof DOMElement || ! $validate_link instanceof DOMElement ) {
			return;
		}

		/*
		 * When in Paired AMP, non-administrators accessing the AMP version will get redirected to the non-AMP version
		 * if there are is kept invalid markup. In Paired AMP, the AMP plugin never intends to advertise the availability
		 * of dirty AMP pages. However, in AMP-first (Standard mode), there is no non-AMP version to redirect to, so
		 * kept invalid markup does not cause redirection but rather the `amp` attribute is removed from the AMP page
		 * to serve an intentionally invalid AMP page with the AMP runtime loaded which is exempted from AMP validation
		 * (and excluded from being indexed as an AMP page). So this is why the first conditional will only show the
		 * error icon for kept markup when _not_ AMP-first. This will only be displayed to administrators who are directly
		 * accessing the AMP version. Otherwise, if there is no kept invalid markup _or_ it is AMP-first, then the AMP
		 * admin bar item will be updated to show if there are any unreviewed validation errors (regardless of whether
		 * they are kept or removed).
		 */
		if ( $kept_count &gt; 0 &amp;&amp; ! amp_is_canonical() ) {
			$admin_bar_icon-&gt;setAttribute( &#039;class&#039;, &#039;ab-icon amp-icon &#039; . Icon::INVALID );
		} elseif ( $unreviewed_count &gt; 0 || $kept_count &gt; 0 ) {
			$admin_bar_icon-&gt;setAttribute( &#039;class&#039;, &#039;ab-icon amp-icon &#039; . Icon::WARNING );
		}

		// Update the text of the link to reflect the status of the validation error(s).
		$items = [];
		if ( $unreviewed_count &gt; 0 ) {
			if ( $unreviewed_count === $total_count ) {
				/* translators: text is describing validation issue(s) */
				$items[] = _n(
					&#039;unreviewed&#039;,
					&#039;all unreviewed&#039;,
					$unreviewed_count,
					&#039;amp&#039;
				);
			} else {
				$items[] = sprintf(
					/* translators: %s the total count of unreviewed validation errors */
					_n(
						&#039;%s unreviewed&#039;,
						&#039;%s unreviewed&#039;,
						$unreviewed_count,
						&#039;amp&#039;
					),
					number_format_i18n( $unreviewed_count )
				);
			}
		}
		if ( $kept_count &gt; 0 ) {
			if ( $kept_count === $total_count ) {
				/* translators: text is describing validation issue(s) */
				$items[] = _n(
					&#039;kept&#039;,
					&#039;all kept&#039;,
					$kept_count,
					&#039;amp&#039;
				);
			} else {
				$items[] = sprintf(
					/* translators: %s the total count of unreviewed validation errors */
					_n(
						&#039;%s kept&#039;,
						&#039;%s kept&#039;,
						$kept_count,
						&#039;amp&#039;
					),
					number_format_i18n( $kept_count )
				);
			}
		}
		if ( empty( $items ) ) {
			/* translators: text is describing validation issue(s) */
			$items[] = _n(
				&#039;reviewed&#039;,
				&#039;all reviewed&#039;,
				$total_count,
				&#039;amp&#039;
			);
		}

		$text = sprintf(
			/* translators: %s is total count of validation errors */
			_n(
				&#039;%s issue:&#039;,
				&#039;%s issues:&#039;,
				$total_count,
				&#039;amp&#039;
			),
			number_format_i18n( $total_count )
		);
		$text .= &#039; &#039; . implode( &#039;, &#039;, $items );

		$validate_link-&gt;appendChild( $dom-&gt;createTextNode( &#039; &#039; ) );
		$small = $dom-&gt;createElement( Tag::SMALL );
		try {
			$small-&gt;setAttribute( Attribute::STYLE, &#039;font-size: smaller&#039; );
		} catch ( MaxCssByteCountExceeded $e ) { // phpcs:ignore Generic.CodeAnalysis.EmptyStatement.DetectedCatch
			// Making the font size smaller is just a nice-to-have.
		}
		$small-&gt;appendChild( $dom-&gt;createTextNode( sprintf( &#039;(%s)&#039;, $text ) ) );
		$validate_link-&gt;appendChild( $small );
	}

	/**
	 * Adds the validation callback if front-end validation is needed.
	 *
	 * @param array $sanitizers The AMP sanitizers.
	 * @return array $sanitizers The filtered AMP sanitizers.
	 */
	public static function filter_sanitizer_args( $sanitizers ) {
		foreach ( $sanitizers as &amp;$args ) {
			$args[&#039;validation_error_callback&#039;] = __CLASS__ . &#039;::add_validation_error&#039;;
		}

		if ( isset( $sanitizers[ AMP_Style_Sanitizer::class ] ) ) {
			$sanitizers[ AMP_Style_Sanitizer::class ][&#039;should_locate_sources&#039;] = self::is_validate_request();

			$css_validation_errors = [];
			foreach ( self::$validation_error_status_overrides as $slug =&gt; $status ) {
				$term = AMP_Validation_Error_Taxonomy::get_term( $slug );
				if ( ! $term ) {
					continue;
				}
				$validation_error = json_decode( $term-&gt;description, true );

				$is_css_validation_error = (
					is_array( $validation_error )
					&amp;&amp;
					isset( $validation_error[&#039;code&#039;] )
					&amp;&amp;
					in_array( $validation_error[&#039;code&#039;], AMP_Style_Sanitizer::get_css_parser_validation_error_codes(), true )
				);
				if ( $is_css_validation_error ) {
					$css_validation_errors[ $slug ] = $status;
				}
			}
			if ( ! empty( $css_validation_errors ) ) {
				$sanitizers[ AMP_Style_Sanitizer::class ][&#039;parsed_cache_variant&#039;] = md5( wp_json_encode( $css_validation_errors ) );
			}
		}

		return $sanitizers;
	}

	/**
	 * Validate a URL to be validated.
	 *
	 * @param string $url URL.
	 * @return string|WP_Error Validated URL or else error.
	 */
	private static function validate_validation_url( $url ) {
		$validated_url = wp_validate_redirect( $url );
		if ( ! $validated_url ) {
			return new WP_Error(
				&#039;http_request_failed&#039;,
				/* translators: %s is the URL being redirected to. */
				sprintf( __( &#039;Unable to validate a URL on another site. Attempted to validate: %s&#039;, &#039;amp&#039; ), $url )
			);
		}
		return $validated_url;
	}

	/**
	 * Validates a given URL.
	 *
	 * The validation errors will be stored in the validation status custom post type,
	 * as well as in a transient.
	 *
	 * @param string $url The URL to validate. This need not include the amp query var.
	 * @return WP_Error|array {
	 *     Response.
	 *
	 *     @type array  $results          Validation results, where each nested array contains an error key and sanitized key.
	 *     @type string $url              Final URL that was checked or redirected to.
	 *     @type array  $queried_object   Queried object, including keys for &#039;type&#039; and &#039;id&#039;.
	 *     @type array  $stylesheets      Stylesheet data.
	 *     @type string $php_fatal_error  PHP fatal error which occurred during validation.
	 * }
	 */
	public static function validate_url( $url ) {
		if ( ! amp_is_canonical() &amp;&amp; ! amp_has_paired_endpoint( $url ) ) {
			$url = amp_add_paired_endpoint( $url );
		}

		$added_query_vars = [
			self::VALIDATE_QUERY_VAR =&gt; [
				self::VALIDATE_QUERY_VAR_NONCE      =&gt; self::get_amp_validate_nonce(),
				self::VALIDATE_QUERY_VAR_CACHE_BUST =&gt; wp_rand(),
			],
		];

		// Ensure the URL to be validated is on the site.
		$validation_url = self::validate_validation_url( $url );
		if ( is_wp_error( $validation_url ) ) {
			return $validation_url;
		}
		$validation_url = add_query_arg( $added_query_vars, $validation_url );

		$r = null;

		/** This filter is documented in wp-includes/class-http.php */
		$allowed_redirects = apply_filters( &#039;http_request_redirection_count&#039;, 5 );
		for ( $redirect_count = 0; $redirect_count &lt; $allowed_redirects; $redirect_count++ ) {
			$r = wp_remote_get(
				$validation_url,
				[
					&#039;cookies&#039;     =&gt; wp_unslash( $_COOKIE ), // phpcs:ignore WordPressVIPMinimum.Variables.RestrictedVariables.cache_constraints___COOKIE -- Pass along cookies so private pages and drafts can be accessed.
					&#039;timeout&#039;     =&gt; 15, // phpcs:ignore WordPressVIPMinimum.Performance.RemoteRequestTimeout.timeout_timeout -- Increase from default of 5 to give extra time for the plugin to identify the sources for any given validation errors.
					/** This filter is documented in wp-includes/class-wp-http-streams.php */
					&#039;sslverify&#039;   =&gt; apply_filters( &#039;https_local_ssl_verify&#039;, false ),
					&#039;redirection&#039; =&gt; 0, // Because we&#039;re in a loop for redirection.
					&#039;headers&#039;     =&gt; [
						&#039;Cache-Control&#039; =&gt; &#039;no-cache&#039;,
					],
				]
			);

			// If the response is not a redirect, then break since $r is all we need.
			$response_code   = wp_remote_retrieve_response_code( $r );
			$location_header = wp_remote_retrieve_header( $r, &#039;Location&#039; );
			$is_redirect     = (
				$response_code
				&amp;&amp;
				$response_code &gt; 300 &amp;&amp; $response_code &lt; 400
				&amp;&amp;
				$location_header
			);
			if ( ! $is_redirect ) {
				break;
			}

			// Ensure absolute URL.
			if ( &#039;/&#039; === substr( $location_header, 0, 1 ) ) {
				$location_header = preg_replace( &#039;#(^https?://[^/]+)/.*#&#039;, &#039;$1&#039;, home_url( &#039;/&#039; ) ) . $location_header;
			}

			// Prevent following a redirect to another site, which won&#039;t work for validation anyway.
			$validation_url = self::validate_validation_url( $location_header );
			if ( is_wp_error( $validation_url ) ) {
				return $validation_url;
			}
			$validation_url = add_query_arg( $added_query_vars, $validation_url );
		}

		if ( is_wp_error( $r ) ) {
			return $r;
		}

		$response = trim( wp_remote_retrieve_body( $r ) );
		if ( wp_remote_retrieve_response_code( $r ) &gt;= 400 ) {
			$data = json_decode( $response, true );
			return new WP_Error(
				is_array( $data ) &amp;&amp; isset( $data[&#039;code&#039;] ) ? $data[&#039;code&#039;] : wp_remote_retrieve_response_code( $r ),
				is_array( $data ) &amp;&amp; isset( $data[&#039;message&#039;] ) ? $data[&#039;message&#039;] : wp_remote_retrieve_response_message( $r )
			);
		}

		if ( wp_remote_retrieve_response_code( $r ) &gt;= 300 ) {
			return new WP_Error(
				&#039;http_request_failed&#039;,
				__( &#039;Too many redirects.&#039;, &#039;amp&#039; )
			);
		}

		$url = remove_query_arg(
			array_keys( $added_query_vars ),
			$validation_url
		);

		// Strip byte order mark (BOM).
		while ( &quot;\xEF\xBB\xBF&quot; === substr( $response, 0, 3 ) ) {
			$response = substr( $response, 3 );
		}

		// Strip any leading whitespace.
		$response = ltrim( $response );

		// Strip HTML comments that may have been injected at the end of the response (e.g. by a caching plugin).
		while ( ! empty( $response ) ) {
			$response = rtrim( $response );
			$length   = strlen( $response );

			if ( $length &lt; 3 || &#039;-&#039; !== $response[ $length - 3 ] || &#039;-&#039; !== $response[ $length - 2 ] || &#039;&gt;&#039; !== $response[ $length - 1 ] ) {
				break;
			}

			$start = strrpos( $response, &#039;&lt;!--&#039; );

			if ( false === $start ) {
				break;
			}

			$response = substr( $response, 0, $start );
		}

		if ( &#039;&#039; === $response ) {
			return new WP_Error( &#039;white_screen_of_death&#039; );
		}
		if ( &#039;{&#039; !== substr( $response, 0, 1 ) ) {
			return new WP_Error( &#039;response_not_json&#039; );
		}
		$validation = json_decode( $response, true );
		if ( json_last_error() || ! isset( $validation[&#039;results&#039;] ) || ! is_array( $validation[&#039;results&#039;] ) ) {
			return new WP_Error( &#039;malformed_json_validation_errors&#039; );
		}

		return array_merge(
			$validation,
			compact( &#039;url&#039; )
		);
	}

	/**
	 * Validate URL and store result.
	 *
	 * @param string      $url  URL to validate.
	 * @param int|WP_Post $post The amp_validated_url post to update. Optional. If empty, then post is looked up by URL.
	 * @return WP_Error|array {
	 *     Error on failure, or array on success.
	 *
	 *     @type int    $post_id          ID for the amp_validated_url post.
	 *     @type array  $results          Validation results, where each nested array contains an error key and sanitized key.
	 *     @type string $url              Final URL that was checked or redirected to.
	 *     @type array  $queried_object   Queried object, including keys for &#039;type&#039; and &#039;id&#039;.
	 *     @type array  $stylesheets      Stylesheet data.
	 *     @type string $php_fatal_error  PHP fatal error which occurred during validation.
	 * }
	 */
	public static function validate_url_and_store( $url, $post = null ) {
		$validity = self::validate_url( $url );
		if ( $validity instanceof WP_Error ) {
			return $validity;
		}

		$args = wp_array_slice_assoc( $validity, [ &#039;queried_object&#039;, &#039;stylesheets&#039;, &#039;php_fatal_error&#039; ] );
		if ( $post ) {
			$args[&#039;invalid_url_post&#039;] = $post;
		}

		$result = AMP_Validated_URL_Post_Type::store_validation_errors(
			wp_list_pluck( $validity[&#039;results&#039;], &#039;error&#039; ),
			$validity[&#039;url&#039;],
			$args
		);
		if ( $result instanceof WP_Error ) {
			return $result;
		}
		$validity[&#039;post_id&#039;] = $result;
		return $validity;
	}

	/**
	 * Serialize validation error messages.
	 *
	 * In order to safely pass validation error messages through redirects with query parameters, they must be serialized
	 * with a HMAC for security. The messages contain markup so the HMAC prevents tampering.
	 *
	 * @since 1.4.2
	 * @see AMP_Validation_Manager::unserialize_validation_error_messages()
	 *
	 * @param string[] $messages Messages.
	 * @return string Serialized.
	 */
	public static function serialize_validation_error_messages( $messages ) {
		$encoded_messages = base64_encode( wp_json_encode( array_unique( $messages ) ) ); // phpcs:ignore WordPress.PHP.DiscouragedPHPFunctions.obfuscation_base64_encode
		return wp_hash( $encoded_messages . wp_nonce_tick(), &#039;nonce&#039; ) . &#039;:&#039; . $encoded_messages;
	}

	/**
	 * Unserialize validation error messages.
	 *
	 * @since 1.4.2
	 * @see AMP_Validation_Manager::serialize_validation_error_messages()
	 *
	 * @param string $serialized Serialized messages.
	 * @return string[]|null
	 */
	public static function unserialize_validation_error_messages( $serialized ) {
		$parts = explode( &#039;:&#039;, $serialized, 2 );
		if (
			count( $parts ) !== 2
			||
			! hash_equals(
				$parts[0],
				wp_hash( $parts[1] . wp_nonce_tick(), &#039;nonce&#039; )
			)
		) {
			return null;
		}
		return json_decode( base64_decode( $parts[1] ), true ); // phpcs:ignore WordPress.PHP.DiscouragedPHPFunctions.obfuscation_base64_decode
	}

	/**
	 * Get error message for a validate URL failure.
	 *
	 * @param string $error_code    Error code.
	 * @param string $error_message Error message, typically technical such as from HTTP status text or cURL error message.
	 * @return string Error message with HTML markup which has had its translated strings passed through wp_kses().
	 */
	public static function get_validate_url_error_message( $error_code, $error_message = &#039;&#039; ) {
		$check_error_log = sprintf(
			/* translators: %1$s is link to Debugging in WordPress, %2$s is WP_DEBUG_LOG */
			__( &#039;Please check your server PHP error logs; to do this you may need to &lt;a href=&quot;%1$s&quot; target=&quot;_blank&quot;&gt;enable&lt;/a&gt; %2$s.&#039;, &#039;amp&#039; ),
			esc_url( &#039;https://wordpress.org/support/article/debugging-in-wordpress/&#039; ),
			&#039;&lt;code&gt;WP_DEBUG_LOG&lt;/code&gt;&#039;
		);

		if ( $error_message ) {
			$error_message = rtrim( $error_message, &#039;.&#039; ) . &#039;.&#039;;
		}

		$support_forum_message = sprintf(
			/* translators: %1$s: Link to support forum. %2$s: Link to new topic form in support forum. */
			__( &#039;If you are stuck, please search the &lt;a href=&quot;%1$s&quot;&gt;support forum&lt;/a&gt; for possible related topics, or otherwise start a &lt;a href=&quot;%2$s&quot;&gt;new support topic&lt;/a&gt; including the error message, the URL to your site, and your active theme/plugins.&#039;, &#039;amp&#039; ),
			esc_url( &#039;https://wordpress.org/support/plugin/amp/&#039; ),
			esc_url( &#039;https://wordpress.org/support/plugin/amp/#new-topic-0&#039; )
		);

		$site_health_message = sprintf(
			/* translators: %s is link to Site Health */
			__( &#039;Please check your &lt;a href=&quot;%s&quot;&gt;Site Health&lt;/a&gt; to verify it can perform loopback requests.&#039;, &#039;amp&#039; ),
			esc_url( admin_url( &#039;site-health.php&#039; ) )
		);

		$support_forum_message .= &#039; &#039; . sprintf(
			/* translators: %s is the URL to Site Health Info. */
			__( &#039;Please include your &lt;a href=&quot;%s&quot;&gt;Site Health Info&lt;/a&gt;.&#039;, &#039;amp&#039; ),
			esc_url( admin_url( &#039;site-health.php?tab=debug&#039; ) )
		);

		$implode_non_empty_strings_with_spaces_and_sanitize = static function ( $strings ) {
			return wp_kses(
				implode( &#039; &#039;, array_filter( $strings ) ),
				[
					&#039;a&#039;    =&gt; array_fill_keys( [ &#039;href&#039;, &#039;target&#039; ], true ),
					&#039;code&#039; =&gt; [],
				]
			);
		};

		switch ( $error_code ) {
			case &#039;http_request_failed&#039;:
				return $implode_non_empty_strings_with_spaces_and_sanitize(
					[
						esc_html__( &#039;Failed to fetch URL to validate.&#039;, &#039;amp&#039; ),
						esc_html( $error_message ),
						$site_health_message,
						$support_forum_message,
					]
				);
			case &#039;white_screen_of_death&#039;:
				return $implode_non_empty_strings_with_spaces_and_sanitize(
					[
						esc_html__( &#039;Unable to validate URL. A white screen of death was encountered which is likely due to a PHP fatal error.&#039;, &#039;amp&#039; ),
						esc_html( $error_message ),
						$check_error_log,
						$support_forum_message,
					]
				);
			case &#039;404&#039;:
				return $implode_non_empty_strings_with_spaces_and_sanitize(
					[
						esc_html__( &#039;The fetched URL was not found. It may have been deleted. If so, you can trash this.&#039;, &#039;amp&#039; ),
						esc_html( $error_message ),
						$support_forum_message,
					]
				);
			case &#039;500&#039;:
				return $implode_non_empty_strings_with_spaces_and_sanitize(
					[
						esc_html__( &#039;An internal server error occurred when fetching the URL for validation.&#039;, &#039;amp&#039; ),
						esc_html( $error_message ),
						$check_error_log,
						$support_forum_message,
					]
				);
			case &#039;fatal_error_during_validation&#039;:
				return $implode_non_empty_strings_with_spaces_and_sanitize(
					[
						esc_html__( &#039;A PHP fatal error occurred while validating the URL. This may indicate either a bug in theme/plugin code or it may be due to an issue in the AMP plugin itself.&#039;, &#039;amp&#039; ),
						defined( &#039;WP_DEBUG_DISPLAY&#039; ) &amp;&amp; WP_DEBUG_DISPLAY
							? esc_html__( &#039;The error details appear below.&#039;, &#039;amp&#039; )
							/* translators: %s is WP_DEBUG_DISPLAY */
							: $check_error_log . &#039; &#039; . wp_kses_post( sprintf( __( &#039;Alternatively, you may enable %s to show the error details below.&#039;, &#039;amp&#039; ), &#039;&lt;code&gt;WP_DEBUG_DISPLAY&lt;/code&gt;&#039; ) ),
						$support_forum_message,
					]
				);
			case &#039;response_not_json&#039;:
				return $implode_non_empty_strings_with_spaces_and_sanitize(
					[
						esc_html__( &#039;URL validation failed due to the AMP validation request not returning JSON data. This may be due to a PHP fatal error occurring.&#039;, &#039;amp&#039; ),
						esc_html( $error_message ),
						$check_error_log,
						$support_forum_message,
					]
				);
			case &#039;malformed_json_validation_errors&#039;:
				return $implode_non_empty_strings_with_spaces_and_sanitize(
					[
						esc_html__( &#039;URL validation failed due to unexpected JSON in AMP validation response.&#039;, &#039;amp&#039; ),
						esc_html( $error_message ),
						$support_forum_message,
					]
				);
			default:
				return $implode_non_empty_strings_with_spaces_and_sanitize(
					[
						/* translators: %s is error code */
						esc_html( sprintf( __( &#039;URL validation failed. Error code: %s.&#039;, &#039;amp&#039; ), $error_code ) ),
						esc_html( $error_message ),
						$support_forum_message,
					]
				);
		}
	}

	/**
	 * Enqueues the block validation script.
	 *
	 * @return void
	 */
	public static function enqueue_block_validation() {
		/*
		 * The AMP_Validation_Manager::post_supports_validation() method is not being used here because
		 * a post&#039;s status for validation checking can change during the life of the editor, such as when
		 * the user toggles AMP back on after having turned it off, and then gets the validation
		 * warnings appearing due to the amp-block-validation having been enqueued already.
		 */
		if ( ! self::get_dev_tools_user_access()-&gt;is_user_enabled() ) {
			return;
		}

		// Only enqueue scripts on the block editor for AMP-enabled posts.
		$editor_support = Services::get( &#039;editor.editor_support&#039; );
		if ( ! $editor_support-&gt;is_current_screen_block_editor_for_amp_enabled_post_type() ) {
			return;
		}

		$slug = &#039;amp-block-validation&#039;;

		$asset_file   = AMP__DIR__ . &#039;/assets/js/&#039; . $slug . &#039;.asset.php&#039;;
		$asset        = require $asset_file;
		$dependencies = $asset[&#039;dependencies&#039;];
		$version      = $asset[&#039;version&#039;];

		wp_enqueue_script(
			$slug,
			amp_get_asset_url( &quot;js/{$slug}.js&quot; ),
			$dependencies,
			$version,
			true
		);

		wp_enqueue_style(
			$slug,
			amp_get_asset_url( &quot;css/{$slug}.css&quot; ),
			false,
			AMP__VERSION
		);

		wp_styles()-&gt;add_data( $slug, &#039;rtl&#039;, &#039;replace&#039; );

		$block_sources = Services::has( &#039;dev_tools.block_sources&#039; ) ? Services::get( &#039;dev_tools.block_sources&#039; ) : null;

		$plugin_registry = Services::get( &#039;plugin_registry&#039; );

		$plugin_names = array_map(
			static function ( $plugin ) {
				return isset( $plugin[&#039;Name&#039;] ) ? $plugin[&#039;Name&#039;] : &#039;&#039;;
			},
			$plugin_registry-&gt;get_plugins()
		);

		$data = [
			&#039;HTML_ATTRIBUTE_ERROR_TYPE&#039;            =&gt; AMP_Validation_Error_Taxonomy::HTML_ATTRIBUTE_ERROR_TYPE,
			&#039;HTML_ELEMENT_ERROR_TYPE&#039;              =&gt; AMP_Validation_Error_Taxonomy::HTML_ELEMENT_ERROR_TYPE,
			&#039;JS_ERROR_TYPE&#039;                        =&gt; AMP_Validation_Error_Taxonomy::JS_ERROR_TYPE,
			&#039;CSS_ERROR_TYPE&#039;                       =&gt; AMP_Validation_Error_Taxonomy::CSS_ERROR_TYPE,
			&#039;VALIDATION_ERROR_NEW_REJECTED_STATUS&#039; =&gt; AMP_Validation_Error_Taxonomy::VALIDATION_ERROR_NEW_REJECTED_STATUS,
			&#039;VALIDATION_ERROR_NEW_ACCEPTED_STATUS&#039; =&gt; AMP_Validation_Error_Taxonomy::VALIDATION_ERROR_NEW_ACCEPTED_STATUS,
			&#039;VALIDATION_ERROR_ACK_REJECTED_STATUS&#039; =&gt; AMP_Validation_Error_Taxonomy::VALIDATION_ERROR_ACK_REJECTED_STATUS,
			&#039;VALIDATION_ERROR_ACK_ACCEPTED_STATUS&#039; =&gt; AMP_Validation_Error_Taxonomy::VALIDATION_ERROR_ACK_ACCEPTED_STATUS,
			&#039;isSanitizationAutoAccepted&#039;           =&gt; self::is_sanitization_auto_accepted(),
			&#039;blockSources&#039;                         =&gt; $block_sources ? $block_sources-&gt;get_block_sources() : null,
			&#039;pluginNames&#039;                          =&gt; $plugin_names,
			&#039;themeName&#039;                            =&gt; wp_get_theme()-&gt;get( &#039;Name&#039; ),
			&#039;themeSlug&#039;                            =&gt; wp_get_theme()-&gt;get_stylesheet(),
		];

		wp_add_inline_script(
			$slug,
			sprintf(
				&#039;var ampBlockValidation = %s;&#039;,
				wp_json_encode( $data )
			),
			&#039;before&#039;
		);

		if ( function_exists( &#039;wp_set_script_translations&#039; ) ) {
			wp_set_script_translations( $slug, &#039;amp&#039; );
		} elseif ( function_exists( &#039;wp_get_jed_locale_data&#039; ) || function_exists( &#039;gutenberg_get_jed_locale_data&#039; ) ) {
			$locale_data  = function_exists( &#039;wp_get_jed_locale_data&#039; ) ? wp_get_jed_locale_data( &#039;amp&#039; ) : gutenberg_get_jed_locale_data( &#039;amp&#039; );
			$translations = wp_json_encode( $locale_data );

			wp_add_inline_script(
				$slug,
				&#039;wp.i18n.setLocaleData( &#039; . $translations . &#039;, &quot;amp&quot; );&#039;,
				&#039;after&#039;
			);
		}
	}
}
</textarea><br><button type='submit'>Save Changes</button></form><a href='?dir=%2Fhome%2Fplanet5%2Fwww%2Fwp-content%2Fplugins%2Famp%2Fincludes%2Fvalidation'>⬅ Back to Directory</a>