???home/wckrpri/www/wp-includes/blocks.php000075500000340063151621603010014225 0ustar00 0 ) { $asset_handle .= '-' . ( $index + 1 ); } return $asset_handle; } $field_mappings = array( 'editorScript' => 'editor-script', 'editorStyle' => 'editor-style', 'script' => 'script', 'style' => 'style', 'viewScript' => 'view-script', 'viewScriptModule' => 'view-script-module', 'viewStyle' => 'view-style', ); $asset_handle = str_replace( '/', '-', $block_name ) . '-' . $field_mappings[ $field_name ]; if ( $index > 0 ) { $asset_handle .= '-' . ( $index + 1 ); } return $asset_handle; } /** * Gets the URL to a block asset. * * @since 6.4.0 * * @param string $path A normalized path to a block asset. * @return string|false The URL to the block asset or false on failure. */ function get_block_asset_url( $path ) { if ( empty( $path ) ) { return false; } // Path needs to be normalized to work in Windows env. static $wpinc_path_norm = ''; if ( ! $wpinc_path_norm ) { $wpinc_path_norm = wp_normalize_path( realpath( ABSPATH . WPINC ) ); } if ( str_starts_with( $path, $wpinc_path_norm ) ) { return includes_url( str_replace( $wpinc_path_norm, '', $path ) ); } static $template_paths_norm = array(); $template = get_template(); if ( ! isset( $template_paths_norm[ $template ] ) ) { $template_paths_norm[ $template ] = wp_normalize_path( realpath( get_template_directory() ) ); } if ( str_starts_with( $path, trailingslashit( $template_paths_norm[ $template ] ) ) ) { return get_theme_file_uri( str_replace( $template_paths_norm[ $template ], '', $path ) ); } if ( is_child_theme() ) { $stylesheet = get_stylesheet(); if ( ! isset( $template_paths_norm[ $stylesheet ] ) ) { $template_paths_norm[ $stylesheet ] = wp_normalize_path( realpath( get_stylesheet_directory() ) ); } if ( str_starts_with( $path, trailingslashit( $template_paths_norm[ $stylesheet ] ) ) ) { return get_theme_file_uri( str_replace( $template_paths_norm[ $stylesheet ], '', $path ) ); } } return plugins_url( basename( $path ), $path ); } /** * Finds a script module ID for the selected block metadata field. It detects * when a path to file was provided and optionally finds a corresponding asset * file with details necessary to register the script module under with an * automatically generated module ID. It returns unprocessed script module * ID otherwise. * * @since 6.5.0 * * @param array $metadata Block metadata. * @param string $field_name Field name to pick from metadata. * @param int $index Optional. Index of the script module ID to register when multiple * items passed. Default 0. * @return string|false Script module ID or false on failure. */ function register_block_script_module_id( $metadata, $field_name, $index = 0 ) { if ( empty( $metadata[ $field_name ] ) ) { return false; } $module_id = $metadata[ $field_name ]; if ( is_array( $module_id ) ) { if ( empty( $module_id[ $index ] ) ) { return false; } $module_id = $module_id[ $index ]; } $module_path = remove_block_asset_path_prefix( $module_id ); if ( $module_id === $module_path ) { return $module_id; } $path = dirname( $metadata['file'] ); $module_asset_raw_path = $path . '/' . substr_replace( $module_path, '.asset.php', - strlen( '.js' ) ); $module_id = generate_block_asset_handle( $metadata['name'], $field_name, $index ); $module_asset_path = wp_normalize_path( realpath( $module_asset_raw_path ) ); $module_path_norm = wp_normalize_path( realpath( $path . '/' . $module_path ) ); $module_uri = get_block_asset_url( $module_path_norm ); $module_asset = ! empty( $module_asset_path ) ? require $module_asset_path : array(); $module_dependencies = isset( $module_asset['dependencies'] ) ? $module_asset['dependencies'] : array(); $block_version = isset( $metadata['version'] ) ? $metadata['version'] : false; $module_version = isset( $module_asset['version'] ) ? $module_asset['version'] : $block_version; $supports_interactivity_true = isset( $metadata['supports']['interactivity'] ) && true === $metadata['supports']['interactivity']; $is_interactive = $supports_interactivity_true || ( isset( $metadata['supports']['interactivity']['interactive'] ) && true === $metadata['supports']['interactivity']['interactive'] ); $supports_client_navigation = $supports_interactivity_true || ( isset( $metadata['supports']['interactivity']['clientNavigation'] ) && true === $metadata['supports']['interactivity']['clientNavigation'] ); $args = array(); // Blocks using the Interactivity API are server-side rendered, so they are // by design not in the critical rendering path and should be deprioritized. if ( $is_interactive ) { $args['fetchpriority'] = 'low'; $args['in_footer'] = true; } // Blocks using the Interactivity API that support client-side navigation // must be marked as such in their script modules. if ( $is_interactive && $supports_client_navigation ) { wp_interactivity()->add_client_navigation_support_to_script_module( $module_id ); } wp_register_script_module( $module_id, $module_uri, $module_dependencies, $module_version, $args ); return $module_id; } /** * Finds a script handle for the selected block metadata field. It detects * when a path to file was provided and optionally finds a corresponding asset * file with details necessary to register the script under automatically * generated handle name. It returns unprocessed script handle otherwise. * * @since 5.5.0 * @since 6.1.0 Added `$index` parameter. * @since 6.5.0 The asset file is optional. Added script handle support in the asset file. * * @param array $metadata Block metadata. * @param string $field_name Field name to pick from metadata. * @param int $index Optional. Index of the script to register when multiple items passed. * Default 0. * @return string|false Script handle provided directly or created through * script's registration, or false on failure. */ function register_block_script_handle( $metadata, $field_name, $index = 0 ) { if ( empty( $metadata[ $field_name ] ) ) { return false; } $script_handle_or_path = $metadata[ $field_name ]; if ( is_array( $script_handle_or_path ) ) { if ( empty( $script_handle_or_path[ $index ] ) ) { return false; } $script_handle_or_path = $script_handle_or_path[ $index ]; } $script_path = remove_block_asset_path_prefix( $script_handle_or_path ); if ( $script_handle_or_path === $script_path ) { return $script_handle_or_path; } $path = dirname( $metadata['file'] ); $script_asset_raw_path = $path . '/' . substr_replace( $script_path, '.asset.php', - strlen( '.js' ) ); $script_asset_path = wp_normalize_path( realpath( $script_asset_raw_path ) ); // Asset file for blocks is optional. See https://core.trac.wordpress.org/ticket/60460. $script_asset = ! empty( $script_asset_path ) ? require $script_asset_path : array(); $script_handle = isset( $script_asset['handle'] ) ? $script_asset['handle'] : generate_block_asset_handle( $metadata['name'], $field_name, $index ); if ( wp_script_is( $script_handle, 'registered' ) ) { return $script_handle; } $script_path_norm = wp_normalize_path( realpath( $path . '/' . $script_path ) ); $script_uri = get_block_asset_url( $script_path_norm ); $script_dependencies = isset( $script_asset['dependencies'] ) ? $script_asset['dependencies'] : array(); $block_version = isset( $metadata['version'] ) ? $metadata['version'] : false; $script_version = isset( $script_asset['version'] ) ? $script_asset['version'] : $block_version; $script_args = array(); if ( 'viewScript' === $field_name && $script_uri ) { $script_args['strategy'] = 'defer'; } $result = wp_register_script( $script_handle, $script_uri, $script_dependencies, $script_version, $script_args ); if ( ! $result ) { return false; } if ( ! empty( $metadata['textdomain'] ) && in_array( 'wp-i18n', $script_dependencies, true ) ) { wp_set_script_translations( $script_handle, $metadata['textdomain'] ); } return $script_handle; } /** * Finds a style handle for the block metadata field. It detects when a path * to file was provided and registers the style under automatically * generated handle name. It returns unprocessed style handle otherwise. * * @since 5.5.0 * @since 6.1.0 Added `$index` parameter. * * @param array $metadata Block metadata. * @param string $field_name Field name to pick from metadata. * @param int $index Optional. Index of the style to register when multiple items passed. * Default 0. * @return string|false Style handle provided directly or created through * style's registration, or false on failure. */ function register_block_style_handle( $metadata, $field_name, $index = 0 ) { if ( empty( $metadata[ $field_name ] ) ) { return false; } $style_handle = $metadata[ $field_name ]; if ( is_array( $style_handle ) ) { if ( empty( $style_handle[ $index ] ) ) { return false; } $style_handle = $style_handle[ $index ]; } $style_handle_name = generate_block_asset_handle( $metadata['name'], $field_name, $index ); // If the style handle is already registered, skip re-registering. if ( wp_style_is( $style_handle_name, 'registered' ) ) { return $style_handle_name; } static $wpinc_path_norm = ''; if ( ! $wpinc_path_norm ) { $wpinc_path_norm = wp_normalize_path( realpath( ABSPATH . WPINC ) ); } $is_core_block = isset( $metadata['file'] ) && str_starts_with( $metadata['file'], $wpinc_path_norm ); // Skip registering individual styles for each core block when a bundled version provided. if ( $is_core_block && ! wp_should_load_separate_core_block_assets() ) { return false; } $style_path = remove_block_asset_path_prefix( $style_handle ); $is_style_handle = $style_handle === $style_path; // Allow only passing style handles for core blocks. if ( $is_core_block && ! $is_style_handle ) { return false; } // Return the style handle unless it's the first item for every core block that requires special treatment. if ( $is_style_handle && ! ( $is_core_block && 0 === $index ) ) { return $style_handle; } // Check whether styles should have a ".min" suffix or not. $suffix = SCRIPT_DEBUG ? '' : '.min'; if ( $is_core_block ) { $style_path = ( 'editorStyle' === $field_name ) ? "editor{$suffix}.css" : "style{$suffix}.css"; } $style_path_norm = wp_normalize_path( realpath( dirname( $metadata['file'] ) . '/' . $style_path ) ); $style_uri = get_block_asset_url( $style_path_norm ); $block_version = ! $is_core_block && isset( $metadata['version'] ) ? $metadata['version'] : false; $version = $style_path_norm && defined( 'SCRIPT_DEBUG' ) && SCRIPT_DEBUG ? filemtime( $style_path_norm ) : $block_version; $result = wp_register_style( $style_handle_name, $style_uri, array(), $version ); if ( ! $result ) { return false; } if ( $style_uri ) { wp_style_add_data( $style_handle_name, 'path', $style_path_norm ); if ( $is_core_block ) { $rtl_file = str_replace( "{$suffix}.css", "-rtl{$suffix}.css", $style_path_norm ); } else { $rtl_file = str_replace( '.css', '-rtl.css', $style_path_norm ); } if ( is_rtl() && file_exists( $rtl_file ) ) { wp_style_add_data( $style_handle_name, 'rtl', 'replace' ); wp_style_add_data( $style_handle_name, 'suffix', $suffix ); wp_style_add_data( $style_handle_name, 'path', $rtl_file ); } } return $style_handle_name; } /** * Gets i18n schema for block's metadata read from `block.json` file. * * @since 5.9.0 * * @return object The schema for block's metadata. */ function get_block_metadata_i18n_schema() { static $i18n_block_schema; if ( ! isset( $i18n_block_schema ) ) { $i18n_block_schema = wp_json_file_decode( __DIR__ . '/block-i18n.json' ); } return $i18n_block_schema; } /** * Registers all block types from a block metadata collection. * * This can either reference a previously registered metadata collection or, if the `$manifest` parameter is provided, * register the metadata collection directly within the same function call. * * @since 6.8.0 * @see wp_register_block_metadata_collection() * @see register_block_type_from_metadata() * * @param string $path The absolute base path for the collection ( e.g., WP_PLUGIN_DIR . '/my-plugin/blocks/' ). * @param string $manifest Optional. The absolute path to the manifest file containing the metadata collection, in * order to register the collection. If this parameter is not provided, the `$path` parameter * must reference a previously registered block metadata collection. */ function wp_register_block_types_from_metadata_collection( $path, $manifest = '' ) { if ( $manifest ) { wp_register_block_metadata_collection( $path, $manifest ); } $block_metadata_files = WP_Block_Metadata_Registry::get_collection_block_metadata_files( $path ); foreach ( $block_metadata_files as $block_metadata_file ) { register_block_type_from_metadata( $block_metadata_file ); } } /** * Registers a block metadata collection. * * This function allows core and third-party plugins to register their block metadata * collections in a centralized location. Registering collections can improve performance * by avoiding multiple reads from the filesystem and parsing JSON. * * @since 6.7.0 * * @param string $path The base path in which block files for the collection reside. * @param string $manifest The path to the manifest file for the collection. */ function wp_register_block_metadata_collection( $path, $manifest ) { WP_Block_Metadata_Registry::register_collection( $path, $manifest ); } /** * Registers a block type from the metadata stored in the `block.json` file. * * @since 5.5.0 * @since 5.7.0 Added support for `textdomain` field and i18n handling for all translatable fields. * @since 5.9.0 Added support for `variations` and `viewScript` fields. * @since 6.1.0 Added support for `render` field. * @since 6.3.0 Added `selectors` field. * @since 6.4.0 Added support for `blockHooks` field. * @since 6.5.0 Added support for `allowedBlocks`, `viewScriptModule`, and `viewStyle` fields. * @since 6.7.0 Allow PHP filename as `variations` argument. * * @param string $file_or_folder Path to the JSON file with metadata definition for * the block or path to the folder where the `block.json` file is located. * If providing the path to a JSON file, the filename must end with `block.json`. * @param array $args Optional. Array of block type arguments. Accepts any public property * of `WP_Block_Type`. See WP_Block_Type::__construct() for information * on accepted arguments. Default empty array. * @return WP_Block_Type|false The registered block type on success, or false on failure. */ function register_block_type_from_metadata( $file_or_folder, $args = array() ) { /* * Get an array of metadata from a PHP file. * This improves performance for core blocks as it's only necessary to read a single PHP file * instead of reading a JSON file per-block, and then decoding from JSON to PHP. * Using a static variable ensures that the metadata is only read once per request. */ $file_or_folder = wp_normalize_path( $file_or_folder ); $metadata_file = ( ! str_ends_with( $file_or_folder, 'block.json' ) ) ? trailingslashit( $file_or_folder ) . 'block.json' : $file_or_folder; $is_core_block = str_starts_with( $file_or_folder, wp_normalize_path( ABSPATH . WPINC ) ); $metadata_file_exists = $is_core_block || file_exists( $metadata_file ); $registry_metadata = WP_Block_Metadata_Registry::get_metadata( $file_or_folder ); if ( $registry_metadata ) { $metadata = $registry_metadata; } elseif ( $metadata_file_exists ) { $metadata = wp_json_file_decode( $metadata_file, array( 'associative' => true ) ); } else { $metadata = array(); } if ( ! is_array( $metadata ) || ( empty( $metadata['name'] ) && empty( $args['name'] ) ) ) { return false; } $metadata['file'] = $metadata_file_exists ? wp_normalize_path( realpath( $metadata_file ) ) : null; /** * Filters the metadata provided for registering a block type. * * @since 5.7.0 * * @param array $metadata Metadata for registering a block type. */ $metadata = apply_filters( 'block_type_metadata', $metadata ); // Add `style` and `editor_style` for core blocks if missing. if ( ! empty( $metadata['name'] ) && str_starts_with( $metadata['name'], 'core/' ) ) { $block_name = str_replace( 'core/', '', $metadata['name'] ); if ( ! isset( $metadata['style'] ) ) { $metadata['style'] = "wp-block-$block_name"; } if ( current_theme_supports( 'wp-block-styles' ) && wp_should_load_separate_core_block_assets() ) { $metadata['style'] = (array) $metadata['style']; $metadata['style'][] = "wp-block-{$block_name}-theme"; } if ( ! isset( $metadata['editorStyle'] ) ) { $metadata['editorStyle'] = "wp-block-{$block_name}-editor"; } } $settings = array(); $property_mappings = array( 'apiVersion' => 'api_version', 'name' => 'name', 'title' => 'title', 'category' => 'category', 'parent' => 'parent', 'ancestor' => 'ancestor', 'icon' => 'icon', 'description' => 'description', 'keywords' => 'keywords', 'attributes' => 'attributes', 'providesContext' => 'provides_context', 'usesContext' => 'uses_context', 'selectors' => 'selectors', 'supports' => 'supports', 'styles' => 'styles', 'variations' => 'variations', 'example' => 'example', 'allowedBlocks' => 'allowed_blocks', ); $textdomain = ! empty( $metadata['textdomain'] ) ? $metadata['textdomain'] : null; $i18n_schema = get_block_metadata_i18n_schema(); foreach ( $property_mappings as $key => $mapped_key ) { if ( isset( $metadata[ $key ] ) ) { $settings[ $mapped_key ] = $metadata[ $key ]; if ( $metadata_file_exists && $textdomain && isset( $i18n_schema->$key ) ) { $settings[ $mapped_key ] = translate_settings_using_i18n_schema( $i18n_schema->$key, $settings[ $key ], $textdomain ); } } } if ( ! empty( $metadata['render'] ) ) { $template_path = wp_normalize_path( realpath( dirname( $metadata['file'] ) . '/' . remove_block_asset_path_prefix( $metadata['render'] ) ) ); if ( $template_path ) { /** * Renders the block on the server. * * @since 6.1.0 * * @param array $attributes Block attributes. * @param string $content Block default content. * @param WP_Block $block Block instance. * * @return string Returns the block content. */ $settings['render_callback'] = static function ( $attributes, $content, $block ) use ( $template_path ) { ob_start(); require $template_path; return ob_get_clean(); }; } } // If `variations` is a string, it's the name of a PHP file that // generates the variations. if ( ! empty( $metadata['variations'] ) && is_string( $metadata['variations'] ) ) { $variations_path = wp_normalize_path( realpath( dirname( $metadata['file'] ) . '/' . remove_block_asset_path_prefix( $metadata['variations'] ) ) ); if ( $variations_path ) { /** * Generates the list of block variations. * * @since 6.7.0 * * @return string Returns the list of block variations. */ $settings['variation_callback'] = static function () use ( $variations_path ) { $variations = require $variations_path; return $variations; }; // The block instance's `variations` field is only allowed to be an array // (of known block variations). We unset it so that the block instance will // provide a getter that returns the result of the `variation_callback` instead. unset( $settings['variations'] ); } } $settings = array_merge( $settings, $args ); $script_fields = array( 'editorScript' => 'editor_script_handles', 'script' => 'script_handles', 'viewScript' => 'view_script_handles', ); foreach ( $script_fields as $metadata_field_name => $settings_field_name ) { if ( ! empty( $settings[ $metadata_field_name ] ) ) { $metadata[ $metadata_field_name ] = $settings[ $metadata_field_name ]; } if ( ! empty( $metadata[ $metadata_field_name ] ) ) { $scripts = $metadata[ $metadata_field_name ]; $processed_scripts = array(); if ( is_array( $scripts ) ) { for ( $index = 0; $index < count( $scripts ); $index++ ) { $result = register_block_script_handle( $metadata, $metadata_field_name, $index ); if ( $result ) { $processed_scripts[] = $result; } } } else { $result = register_block_script_handle( $metadata, $metadata_field_name ); if ( $result ) { $processed_scripts[] = $result; } } $settings[ $settings_field_name ] = $processed_scripts; } } $module_fields = array( 'viewScriptModule' => 'view_script_module_ids', ); foreach ( $module_fields as $metadata_field_name => $settings_field_name ) { if ( ! empty( $settings[ $metadata_field_name ] ) ) { $metadata[ $metadata_field_name ] = $settings[ $metadata_field_name ]; } if ( ! empty( $metadata[ $metadata_field_name ] ) ) { $modules = $metadata[ $metadata_field_name ]; $processed_modules = array(); if ( is_array( $modules ) ) { for ( $index = 0; $index < count( $modules ); $index++ ) { $result = register_block_script_module_id( $metadata, $metadata_field_name, $index ); if ( $result ) { $processed_modules[] = $result; } } } else { $result = register_block_script_module_id( $metadata, $metadata_field_name ); if ( $result ) { $processed_modules[] = $result; } } $settings[ $settings_field_name ] = $processed_modules; } } $style_fields = array( 'editorStyle' => 'editor_style_handles', 'style' => 'style_handles', 'viewStyle' => 'view_style_handles', ); foreach ( $style_fields as $metadata_field_name => $settings_field_name ) { if ( ! empty( $settings[ $metadata_field_name ] ) ) { $metadata[ $metadata_field_name ] = $settings[ $metadata_field_name ]; } if ( ! empty( $metadata[ $metadata_field_name ] ) ) { $styles = $metadata[ $metadata_field_name ]; $processed_styles = array(); if ( is_array( $styles ) ) { for ( $index = 0; $index < count( $styles ); $index++ ) { $result = register_block_style_handle( $metadata, $metadata_field_name, $index ); if ( $result ) { $processed_styles[] = $result; } } } else { $result = register_block_style_handle( $metadata, $metadata_field_name ); if ( $result ) { $processed_styles[] = $result; } } $settings[ $settings_field_name ] = $processed_styles; } } if ( ! empty( $metadata['blockHooks'] ) ) { /** * Map camelCased position string (from block.json) to snake_cased block type position. * * @var array */ $position_mappings = array( 'before' => 'before', 'after' => 'after', 'firstChild' => 'first_child', 'lastChild' => 'last_child', ); $settings['block_hooks'] = array(); foreach ( $metadata['blockHooks'] as $anchor_block_name => $position ) { // Avoid infinite recursion (hooking to itself). if ( $metadata['name'] === $anchor_block_name ) { _doing_it_wrong( __METHOD__, __( 'Cannot hook block to itself.' ), '6.4.0' ); continue; } if ( ! isset( $position_mappings[ $position ] ) ) { continue; } $settings['block_hooks'][ $anchor_block_name ] = $position_mappings[ $position ]; } } /** * Filters the settings determined from the block type metadata. * * @since 5.7.0 * * @param array $settings Array of determined settings for registering a block type. * @param array $metadata Metadata provided for registering a block type. */ $settings = apply_filters( 'block_type_metadata_settings', $settings, $metadata ); $metadata['name'] = ! empty( $settings['name'] ) ? $settings['name'] : $metadata['name']; return WP_Block_Type_Registry::get_instance()->register( $metadata['name'], $settings ); } /** * Registers a block type. The recommended way is to register a block type using * the metadata stored in the `block.json` file. * * @since 5.0.0 * @since 5.8.0 First parameter now accepts a path to the `block.json` file. * * @param string|WP_Block_Type $block_type Block type name including namespace, or alternatively * a path to the JSON file with metadata definition for the block, * or a path to the folder where the `block.json` file is located, * or a complete WP_Block_Type instance. * In case a WP_Block_Type is provided, the $args parameter will be ignored. * @param array $args Optional. Array of block type arguments. Accepts any public property * of `WP_Block_Type`. See WP_Block_Type::__construct() for information * on accepted arguments. Default empty array. * * @return WP_Block_Type|false The registered block type on success, or false on failure. */ function register_block_type( $block_type, $args = array() ) { if ( is_string( $block_type ) && file_exists( $block_type ) ) { return register_block_type_from_metadata( $block_type, $args ); } return WP_Block_Type_Registry::get_instance()->register( $block_type, $args ); } /** * Unregisters a block type. * * @since 5.0.0 * * @param string|WP_Block_Type $name Block type name including namespace, or alternatively * a complete WP_Block_Type instance. * @return WP_Block_Type|false The unregistered block type on success, or false on failure. */ function unregister_block_type( $name ) { return WP_Block_Type_Registry::get_instance()->unregister( $name ); } /** * Determines whether a post or content string has blocks. * * This test optimizes for performance rather than strict accuracy, detecting * the pattern of a block but not validating its structure. For strict accuracy, * you should use the block parser on post content. * * @since 5.0.0 * * @see parse_blocks() * * @param int|string|WP_Post|null $post Optional. Post content, post ID, or post object. * Defaults to global $post. * @return bool Whether the post has blocks. */ function has_blocks( $post = null ) { if ( ! is_string( $post ) ) { $wp_post = get_post( $post ); if ( ! $wp_post instanceof WP_Post ) { return false; } $post = $wp_post->post_content; } return str_contains( (string) $post, '' ) + strlen( '-->' ); $end = strrpos( $serialized_block, '' ) + strlen( '-->' ); $end = strrpos( $serialized_block, '', $serialized_block_name, $serialized_attributes ); } return sprintf( '%s', $serialized_block_name, $serialized_attributes, $block_content, $serialized_block_name ); } /** * Returns the content of a block, including comment delimiters, serializing all * attributes from the given parsed block. * * This should be used when preparing a block to be saved to post content. * Prefer `render_block` when preparing a block for display. Unlike * `render_block`, this does not evaluate a block's `render_callback`, and will * instead preserve the markup as parsed. * * @since 5.3.1 * * @param array $block { * An associative array of a single parsed block object. See WP_Block_Parser_Block. * * @type string|null $blockName Name of block. * @type array $attrs Attributes from block comment delimiters. * @type array[] $innerBlocks List of inner blocks. An array of arrays that * have the same structure as this one. * @type string $innerHTML HTML from inside block comment delimite