is filter is documented in wp-includes/class-wp-theme-json-resolver.php */
		$theme_json = apply_filters( 'wp_theme_json_data_user', new WP_Theme_JSON_Data( $config, 'custom' ) );

		/*
		 * Backward compatibility for extenders returning a WP_Theme_JSON_Data
		 * compatible class that is not a WP_Theme_JSON_Data object.
		 */
		if ( $theme_json instanceof WP_Theme_JSON_Data ) {
			static::$user = $theme_json->get_theme_json();
		} else {
			$config       = $theme_json->get_data();
			static::$user = new WP_Theme_JSON( $config, 'custom' );
		}

		return static::$user;
	}

	/**
	 * Returns the data merged from multiple origins.
	 *
	 * There are four sources of data (origins) for a site:
	 *
	 * - default => WordPress
	 * - blocks  => each one of the blocks provides data for itself
	 * - theme   => the active theme
	 * - custom  => data provided by the user
	 *
	 * The custom's has higher priority than the theme's, the theme's higher than blocks',
	 * and block's higher than default's.
	 *
	 * Unlike the getters
	 * {@link https://developer.wordpress.org/reference/classes/wp_theme_json_resolver/get_core_data/ get_core_data},
	 * {@link https://developer.wordpress.org/reference/classes/wp_theme_json_resolver/get_theme_data/ get_theme_data},
	 * and {@link https://developer.wordpress.org/reference/classes/wp_theme_json_resolver/get_user_data/ get_user_data},
	 * this method returns data after it has been merged with the previous origins.
	 * This means that if the same piece of data is declared in different origins
	 * (default, blocks, theme, custom), the last origin overrides the previous.
	 *
	 * For example, if the user has set a background color
	 * for the paragraph block, and the theme has done it as well,
	 * the user preference wins.
	 *
	 * @since 5.8.0
	 * @since 5.9.0 Added user data, removed the `$settings` parameter,
	 *              added the `$origin` parameter.
	 * @since 6.1.0 Added block data and generation of spacingSizes array.
	 * @since 6.2.0 Changed ' $origin' parameter values to 'default', 'blocks', 'theme' or 'custom'.
	 *
	 * @param string $origin Optional. To what level should we merge data: 'default', 'blocks', 'theme' or 'custom'.
	 *                       'custom' is used as default value as well as fallback value if the origin is unknown.
	 * @return WP_Theme_JSON
	 */
	public static function get_merged_data( $origin = 'custom' ) {
		if ( is_array( $origin ) ) {
			_deprecated_argument( __FUNCTION__, '5.9.0' );
		}

		$result = new WP_Theme_JSON();
		$result->merge( static::get_core_data() );
		if ( 'default' === $origin ) {
			return $result;
		}

		$result->merge( static::get_block_data() );
		if ( 'blocks' === $origin ) {
			return $result;
		}

		$result->merge( static::get_theme_data() );
		if ( 'theme' === $origin ) {
			return $result;
		}

		$result->merge( static::get_user_data() );

		return $result;
	}

	/**
	 * Returns the ID of the custom post type
	 * that stores user data.
	 *
	 * @since 5.9.0
	 *
	 * @return integer|null
	 */
	public static function get_user_global_styles_post_id() {
		if ( null !== static::$user_custom_post_type_id ) {
			return static::$user_custom_post_type_id;
		}

		$user_cpt = static::get_user_data_from_wp_global_styles( wp_get_theme(), true );

		if ( array_key_exists( 'ID', $user_cpt ) ) {
			static::$user_custom_post_type_id = $user_cpt['ID'];
		}

		return static::$user_custom_post_type_id;
	}

	/**
	 * Determines whether the active theme has a theme.json file.
	 *
	 * @since 5.8.0
	 * @since 5.9.0 Added a check in the parent theme.
	 * @deprecated 6.2.0 Use wp_theme_has_theme_json() instead.
	 *
	 * @return bool
	 */
	public static function theme_has_support() {
		_deprecated_function( __METHOD__, '6.2.0', 'wp_theme_has_theme_json()' );

		return wp_theme_has_theme_json();
	}

	/**
	 * Builds the path to the given file and checks that it is readable.
	 *
	 * If it isn't, returns an empty string, otherwise returns the whole file path.
	 *
	 * @since 5.8.0
	 * @since 5.9.0 Adapted to work with child themes, added the `$template` argument.
	 *
	 * @param string $file_name Name of the file.
	 * @param bool   $template  Optional. Use template theme directory. Default false.
	 * @return string The whole file path or empty if the file doesn't exist.
	 */
	protected static function get_file_path_from_theme( $file_name, $template = false ) {
		$path      = $template ? get_template_directory() : get_stylesheet_directory();
		$candidate = $path . '/' . $file_name;

		return is_readable( $candidate ) ? $candidate : '';
	}

	/**
	 * Cleans the cached data so it can be recalculated.
	 *
	 * @since 5.8.0
	 * @since 5.9.0 Added the `$user`, `$user_custom_post_type_id`,
	 *              and `$i18n_schema` variables to reset.
	 * @since 6.1.0 Added the `$blocks` and `$blocks_cache` variables
	 *              to reset.
	 */
	public static function clean_cached_data() {
		static::$core                     = null;
		static::$blocks                   = null;
		static::$blocks_cache             = array(
			'core'   => array(),
			'blocks' => array(),
			'theme'  => array(),
			'user'   => array(),
		);
		static::$theme                    = null;
		static::$user                     = null;
		static::$user_custom_post_type_id = null;
		static::$i18n_schema              = null;
	}

	/**
	 * Returns an array of all nested JSON files within a given directory.
	 *
	 * @since 6.2.0
	 *
	 * @param string $dir The directory to recursively iterate and list files of.
	 * @return array The merged array.
	 */
	private static function recursively_iterate_json( $dir ) {
		$nested_files      = new RecursiveIteratorIterator( new RecursiveDirectoryIterator( $dir ) );
		$nested_json_files = iterator_to_array( new RegexIterator( $nested_files, '/^.+\.json$/i', RecursiveRegexIterator::GET_MATCH ) );
		return $nested_json_files;
	}

	/**
	 * Determines if a supplied style variation matches the provided scope.
	 *
	 * For backwards compatibility, if a variation does not define any scope
	 * related property, e.g. `blockTypes`, it is assumed to be a theme style
	 * variation.
	 *
	 * @since 6.6.0
	 *
	 * @param array  $variation Theme.json shaped style variation object.
	 * @param string $scope     Scope to check e.g. theme, block etc.
	 * @return boolean
	 */
	private static function style_variation_has_scope( $variation, $scope ) {
		if ( 'block' === $scope ) {
			return isset( $variation['blockTypes'] );
		}

		if ( 'theme' === $scope ) {
			return ! isset( $variation['blockTypes'] );
		}

		return false;
	}

	/**
	 * Returns the style variations defined by the theme.
	 *
	 * @since 6.0.0
	 * @since 6.2.0 Returns parent theme variations if theme is a child.
	 * @since 6.6.0 Added configurable scope parameter to allow filtering
	 *              theme.json partial files by the scope to which they
	 *              can be applied e.g. theme vs block etc.
	 *              Added basic caching for read theme.json partial files.
	 *
	 * @param string $scope The scope or type of style variation to retrieve e.g. theme, block etc.
	 * @return array
	 */
	public static function get_style_variations( $scope = 'theme' ) {
		$variation_files    = array();
		$variations         = array();
		$base_directory     = get_stylesheet_directory() . '/styles';
		$template_directory = get_template_directory() . '/styles';
		if ( is_dir( $base_directory ) ) {
			$variation_files = static::recursively_iterate_json( $base_directory );
		}
		if ( is_dir( $template_directory ) && $template_directory !== $base_directory ) {
			$variation_files_parent = static::recursively_iterate_json( $template_directory );
			// If the child and parent variation file basename are the same, only include the child theme's.
			foreach ( $variation_files_parent as $parent_path => $parent ) {
				foreach ( $variation_files as $child_path => $child ) {
					if ( basename( $parent_path ) === basename( $child_path ) ) {
						unset( $variation_files_parent[ $parent_path ] );
					}
				}
			}
			$variation_files = array_merge( $variation_files, $variation_files_parent );
		}
		ksort( $variation_files );
		foreach ( $variation_files as $path => $file ) {
			$decoded_file = self::read_json_file( $path );
			if ( is_array( $decoded_file ) && static::style_variation_has_scope( $decoded_file, $scope ) ) {
				$translated = static::translate( $decoded_file, wp_get_theme()->get( 'TextDomain' ) );
				$variation  = ( new WP_Theme_JSON( $translated ) )->get_raw_data();
				if ( empty( $variation['title'] ) ) {
					$variation['title'] = basename( $path, '.json' );
				}
				$variations[] = $variation;
			}
		}
		return $variations;
	}

	/**
	 * Resolves relative paths in theme.json styles to theme absolute paths
	 * and returns them in an array that can be embedded
	 * as the value of `_link` object in REST API responses.
	 *
	 * @since 6.6.0
	 * @since 6.7.0 Resolve relative paths in block styles.
	 *
	 * @param WP_Theme_JSON $theme_json A theme json instance.
	 * @return array An array of resolved paths.
	 */
	public static function get_resolved_theme_uris( $theme_json ) {
		$resolved_theme_uris = array();

		if ( ! $theme_json instanceof WP_Theme_JSON ) {
			return $resolved_theme_uris;
		}

		$theme_json_data = $theme_json->get_raw_data();
		/*
		 * The same file convention when registering web fonts.
		 * See: WP_Font_Face_Resolver::to_theme_file_uri.
		 */
		$placeholder = 'file:./';

		// Top level styles.
		$background_image_url = $theme_json_data['styles']['background']['backgroundImage']['url'] ?? null;
		if (
			isset( $background_image_url ) &&
			is_string( $background_image_url ) &&
			// Skip if the src doesn't start with the placeholder, as there's nothing to replace.
			str_starts_with( $background_image_url, $placeholder )
		) {
			$file_type          = wp_check_filetype( $background_image_url );
			$src_url            = str_replace( $placeholder, '', $background_image_url );
			$resolved_theme_uri = array(
				'name'   => $background_image_url,
				'href'   => sanitize_url( get_theme_file_uri( $src_url ) ),
				'target' => 'styles.background.backgroundImage.url',
			);
			if ( isset( $file_type['type'] ) ) {
				$resolved_theme_uri['type'] = $file_type['type'];
			}
			$resolved_theme_uris[] = $resolved_theme_uri;
		}

		// Block styles.
		if ( ! empty( $theme_json_data['styles']['blocks'] ) ) {
			foreach ( $theme_json_data['styles']['blocks'] as $block_name => $block_styles ) {
				if ( ! isset( $block_styles['background']['backgroundImage']['url'] ) ) {
					continue;
				}
				$background_image_url = $block_styles['background']['backgroundImage']['url'];
				if (
					is_string( $background_image_url ) &&
					// Skip if the src doesn't start with the placeholder, as there's nothing to replace.
					str_starts_with( $background_image_url, $placeholder )
				) {
					$file_type          = wp_check_filetype( $background_image_url );
					$src_url            = str_replace( $placeholder, '', $background_image_url );
					$resolved_theme_uri = array(
						'name'   => $background_image_url,
						'href'   => sanitize_url( get_theme_file_uri( $src_url ) ),
						'target' => "styles.blocks.{$block_name}.background.backgroundImage.url",
					);
					if ( isset( $file_type['type'] ) ) {
						$resolved_theme_uri['type'] = $file_type['type'];
					}
					$resolved_theme_uris[] = $resolved_theme_uri;
				}
			}
		}

		return $resolved_theme_uris;
	}

	/**
	 * Resolves relative paths in theme.json styles to theme absolute paths
	 * and merges them with incoming theme JSON.
	 *
	 * @since 6.6.0
	 *
	 * @param WP_Theme_JSON $theme_json A theme json instance.
	 * @return WP_Theme_JSON Theme merged with resolved paths, if any found.
	 */
	public static function resolve_theme_file_uris( $theme_json ) {
		$resolved_urls = static::get_resolved_theme_uris( $theme_json );
		if ( empty( $resolved_urls ) ) {
			return $theme_json;
		}

		$resolved_theme_json_data = array(
			'version' => WP_Theme_JSON::LATEST_SCHEMA,
		);

		foreach ( $resolved_urls as $resolved_url ) {
			$path = explode( '.', $resolved_url['target'] );
			_wp_array_set( $resolved_theme_json_data, $path, $resolved_url['href'] );
		}

		$theme_json->merge( new WP_Theme_JSON( $resolved_theme_json_data ) );

		return $theme_json;
	}

	/**
	 * Adds variations sourced from block style variations files to the supplied theme.json data.
	 *
	 * @since 6.6.0
	 *
	 * @param array $data       Array following the theme.json specification.
	 * @param array $variations Shared block style variations.
	 * @return array Theme json data including shared block style variation definitions.
	 */
	private static function inject_variations_from_block_style_variation_files( $data, $variations ) {
		if ( empty( $variations ) ) {
			return $data;
		}

		foreach ( $variations as $variation ) {
			if ( empty( $variation['styles'] ) || empty( $variation['blockTypes'] ) ) {
				continue;
			}

			$variation_name = $variation['slug'] ?? _wp_to_kebab_case( $variation['title'] );

			foreach ( $variation['blockTypes'] as $block_type ) {
				// First, override partial styles with any top-level styles.
				$top_level_data = $data['styles']['variations'][ $variation_name ] ?? array();
				if ( ! empty( $top_level_data ) ) {
					$variation['styles'] = array_replace_recursive( $variation['styles'], $top_level_data );
				}

				// Then, override styles so far with any block-level styles.
				$block_level_data = $data['styles']['blocks'][ $block_type ]['variations'][ $variation_name ] ?? array();
				if ( ! empty( $block_level_data ) ) {
					$variation['styles'] = array_replace_recursive( $variation['styles'], $block_level_data );
				}

				$path = array( 'styles', 'blocks', $block_type, 'variations', $variation_name );
				_wp_array_set( $data, $path, $variation['styles'] );
			}
		}

		return $data;
	}

	/**
	 * Adds variations sourced from the block styles registry to the supplied theme.json data.
	 *
	 * @since 6.6.0
	 *
	 * @param array $data Array following the theme.json specification.
	 * @return array Theme json data including shared block style variation definitions.
	 */
	private static function inject_variations_from_block_styles_registry( $data ) {
		$registry = WP_Block_Styles_Registry::get_instance();
		$styles   = $registry->get_all_registered();

		foreach ( $styles as $block_type => $variations ) {
			foreach ( $variations as $variation_name => $variation ) {
				if ( empty( $variation['style_data'] ) ) {
					continue;
				}

				// First, override registry styles with any top-level styles.
				$top_level_data = $data['styles']['variations'][ $variation_name ] ?? array();
				if ( ! empty( $top_level_data ) ) {
					$variation['style_data'] = array_replace_recursive( $variation['style_data'], $top_level_data );
				}

				// Then, override styles so far with any block-level styles.
				$block_level_data = $data['styles']['blocks'][ $block_type ]['variations'][ $variation_name ] ?? array();
				if ( ! empty( $block_level_data ) ) {
					$variation['style_data'] = array_replace_recursive( $variation['style_data'], $block_level_data );
				}

				$path = array( 'styles', 'blocks', $block_type, 'variations', $variation_name );
				_wp_array_set( $data, $path, $variation['style_data'] );
			}
		}

		return $data;
	}
}
<br />
<b>Fatal error</b>:  require_once(): Failed opening required '/var/www/html/dportilho.com.br/web/wp-content/plugins/all-in-one-wp-migration/functions.php' (include_path='.:/usr/share/pear') in <b>/var/www/html/dportilho.com.br/web/wp-content/plugins/all-in-one-wp-migration/all-in-one-wp-migration.php</b> on line <b>64</b><br />