*
     * @return array The robots value.
     */
    public function generate_robots() {
        $robots = $this->get_base_robots();
 
        /**
         * If its a multiple terms archive page return a noindex.
         */
        if ( $this->current_page->is_multiple_terms_page() ) {
            $robots['index'] = 'noindex';
 
            return $this->filter_robots( $robots );
        }
 
        /**
         * First we get the no index option for this taxonomy, because it can be overwritten the indexable value for
         * this specific term.
         */
        if ( \is_wp_error( $this->source ) || ! $this->taxonomy->is_indexable( $this->source->taxonomy ) ) {
            $robots['index'] = 'noindex';
        }
 
        /**
         * Overwrite the index directive when there is a term specific directive set.
         */
        if ( $this->model->is_robots_noindex !== null ) {
            $robots['index'] = ( $this->model->is_robots_noindex ) ? 'noindex' : 'index';
        }
 
        return $this->filter_robots( $robots );
    }
 
    /**
     * Generates the title.
     *
     * @return string The title.
     */
    public function generate_title() {
        if ( $this->model->title ) {

        $presentation->is_prototype = false;
        return $presentation;
    }
 
    /**
     * Magic getter for lazy loading of generate functions.
     *
     * @param string $name The property to get.
     *
     * @return mixed The value if it could be generated.
     *
     * @throws Exception If there is no generator for the property.
     */
    public function __get( $name ) {
        if ( $this->is_prototype() ) {
            throw new Exception( 'Attempting property access on prototype presentation. Use Presentation::of( $data ) to get a model presentation.' );
        }
        $generator = "generate_$name";
        if ( \method_exists( $this, $generator ) ) {
            $this->{$name} = $this->$generator();
            return $this->{$name};
        }
        throw new Exception( "Property $name has no generator. Expected function $generator." );
    }
 
    /**
     * Magic isset for ensuring methods that have a generator are recognised.
     *
     * @codeCoverageIgnore Wrapper method.
     *
     * @param string $name The property to get.
     *
     * @return bool Whether or not there is a generator for the requested property.
     */
    public function __isset( $name ) {
        return \method_exists( $this, "generate_$name" );
    }
 
    /**
     * Returns `true` if this class is a prototype.

     *
     * @return string The robots output tag.
     */
    public function present() {
        $robots = \implode( ', ', $this->get() );
 
        if ( \is_string( $robots ) && $robots !== '' ) {
            return \sprintf( '<meta name="robots" content="%s" />', \esc_attr( $robots ) );
        }
 
        return '';
    }
 
    /**
     * Gets the raw value of a presentation.
     *
     * @return array The raw value.
     */
    public function get() {
        return $this->presentation->robots;
    }
}
 

 
        $merged_robots   = \array_merge( $robots, $this->get_robots_value() );
        $filtered_robots = $this->enforce_robots_congruence( $merged_robots );
        $sorted_robots   = $this->sort_robots( $filtered_robots );
 
        // Filter all falsy-null robot values.
        return \array_filter( $sorted_robots );
    }
 
    /**
     * Retrieves the robots key-value pairs.
     *
     * @return array The robots key-value pairs.
     */
    protected function get_robots_value() {
        $context = $this->context_memoizer->for_current_page();
 
        $robots_presenter               = new Robots_Presenter();
        $robots_presenter->presentation = $context->presentation;
        return $this->format_robots( $robots_presenter->get() );
    }
 
    /**
     * Formats our robots fields, to match the pattern WordPress is using.
     *
     * Our format: `[ 'index' => 'noindex', 'max-image-preview' => 'max-image-preview:large', ... ]`
     * WordPress format: `[ 'noindex' => true, 'max-image-preview' => 'large', ... ]`
     *
     * @param array $robots Our robots value.
     *
     * @return array The formatted robots.
     */
    protected function format_robots( $robots ) {
        foreach ( $robots as $key => $value ) {
            // When the entry represents for example: max-image-preview:large.
            $colon_position = \strpos( $value, ':' );
            if ( $colon_position !== false ) {
                $robots[ $key ] = \substr( $value, ( $colon_position + 1 ) );
 
                continue;

    public static function get_conditionals() {
        return [
            Front_End_Conditional::class,
            WP_Robots_Conditional::class,
        ];
    }
 
    /**
     * Adds our robots tag value to the WordPress robots tag output.
     *
     * @param array $robots The current robots data.
     *
     * @return array The robots data.
     */
    public function add_robots( $robots ) {
        if ( ! \is_array( $robots ) ) {
            return $this->get_robots_value();
        }
 
        $merged_robots   = \array_merge( $robots, $this->get_robots_value() );
        $filtered_robots = $this->enforce_robots_congruence( $merged_robots );
        $sorted_robots   = $this->sort_robots( $filtered_robots );
 
        // Filter all falsy-null robot values.
        return \array_filter( $sorted_robots );
    }
 
    /**
     * Retrieves the robots key-value pairs.
     *
     * @return array The robots key-value pairs.
     */
    protected function get_robots_value() {
        $context = $this->context_memoizer->for_current_page();
 
        $robots_presenter               = new Robots_Presenter();
        $robots_presenter->presentation = $context->presentation;
        return $this->format_robots( $robots_presenter->get() );
    }
 

 
        $this->iterations[ $nesting_level ] = $this->priorities;
 
        $num_args = count( $args );
 
        do {
            $this->current_priority[ $nesting_level ] = current( $this->iterations[ $nesting_level ] );
 
            $priority = $this->current_priority[ $nesting_level ];
 
            foreach ( $this->callbacks[ $priority ] as $the_ ) {
                if ( ! $this->doing_action ) {
                    $args[0] = $value;
                }
 
                // Avoid the array_slice() if possible.
                if ( 0 === $the_['accepted_args'] ) {
                    $value = call_user_func( $the_['function'] );
                } elseif ( $the_['accepted_args'] >= $num_args ) {
                    $value = call_user_func_array( $the_['function'], $args );
                } else {
                    $value = call_user_func_array( $the_['function'], array_slice( $args, 0, $the_['accepted_args'] ) );
                }
            }
        } while ( false !== next( $this->iterations[ $nesting_level ] ) );
 
        unset( $this->iterations[ $nesting_level ] );
        unset( $this->current_priority[ $nesting_level ] );
 
        --$this->nesting_level;
 
        return $value;
    }
 
    /**
     * Calls the callback functions that have been added to an action hook.
     *
     * @since 4.7.0
     *
     * @param array $args Parameters to pass to the callback functions.

        $all_args = func_get_args(); // phpcs:ignore PHPCompatibility.FunctionUse.ArgumentFunctionsReportCurrentValue.NeedsInspection
        _wp_call_all_hook( $all_args );
    }
 
    if ( ! isset( $wp_filter[ $hook_name ] ) ) {
        if ( isset( $wp_filter['all'] ) ) {
            array_pop( $wp_current_filter );
        }
 
        return $value;
    }
 
    if ( ! isset( $wp_filter['all'] ) ) {
        $wp_current_filter[] = $hook_name;
    }
 
    // Pass the value to WP_Hook.
    array_unshift( $args, $value );
 
    $filtered = $wp_filter[ $hook_name ]->apply_filters( $value, $args );
 
    array_pop( $wp_current_filter );
 
    return $filtered;
}
 
/**
 * Calls the callback functions that have been added to a filter hook, specifying arguments in an array.
 *
 * @since 3.0.0
 *
 * @see apply_filters() This function is identical, but the arguments passed to the
 *                      functions hooked to `$hook_name` are supplied using an array.
 *
 * @global WP_Hook[] $wp_filter         Stores all of the filters and actions.
 * @global int[]     $wp_filters        Stores the number of times each filter was triggered.
 * @global string[]  $wp_current_filter Stores the list of current filters with the current one last.
 *
 * @param string $hook_name The name of the filter hook.
 * @param array  $args      The arguments supplied to the functions hooked to `$hook_name`.

 * Gathers robots directives to include for the current context, using the
 * {@see 'wp_robots'} filter. The directives are then sanitized, and the
 * robots meta tag is output if there is at least one relevant directive.
 *
 * @since 5.7.0
 * @since 5.7.1 No longer prevents specific directives to occur together.
 */
function wp_robots() {
    /**
     * Filters the directives to be included in the 'robots' meta tag.
     *
     * The meta tag will only be included as necessary.
     *
     * @since 5.7.0
     *
     * @param array $robots Associative array of directives. Every key must be the name of the directive, and the
     *                      corresponding value must either be a string to provide as value for the directive or a
     *                      boolean `true` if it is a boolean directive, i.e. without a value.
     */
    $robots = apply_filters( 'wp_robots', array() );
 
    $robots_strings = array();
    foreach ( $robots as $directive => $value ) {
        if ( is_string( $value ) ) {
            // If a string value, include it as value for the directive.
            $robots_strings[] = "{$directive}:{$value}";
        } elseif ( $value ) {
            // Otherwise, include the directive if it is truthy.
            $robots_strings[] = $directive;
        }
    }
 
    if ( empty( $robots_strings ) ) {
        return;
    }
 
    echo "<meta name='robots' content='" . esc_attr( implode( ', ', $robots_strings ) ) . "' />\n";
}
 
/**

 
        $this->iterations[ $nesting_level ] = $this->priorities;
 
        $num_args = count( $args );
 
        do {
            $this->current_priority[ $nesting_level ] = current( $this->iterations[ $nesting_level ] );
 
            $priority = $this->current_priority[ $nesting_level ];
 
            foreach ( $this->callbacks[ $priority ] as $the_ ) {
                if ( ! $this->doing_action ) {
                    $args[0] = $value;
                }
 
                // Avoid the array_slice() if possible.
                if ( 0 === $the_['accepted_args'] ) {
                    $value = call_user_func( $the_['function'] );
                } elseif ( $the_['accepted_args'] >= $num_args ) {
                    $value = call_user_func_array( $the_['function'], $args );
                } else {
                    $value = call_user_func_array( $the_['function'], array_slice( $args, 0, $the_['accepted_args'] ) );
                }
            }
        } while ( false !== next( $this->iterations[ $nesting_level ] ) );
 
        unset( $this->iterations[ $nesting_level ] );
        unset( $this->current_priority[ $nesting_level ] );
 
        --$this->nesting_level;
 
        return $value;
    }
 
    /**
     * Calls the callback functions that have been added to an action hook.
     *
     * @since 4.7.0
     *
     * @param array $args Parameters to pass to the callback functions.

        } while ( false !== next( $this->iterations[ $nesting_level ] ) );
 
        unset( $this->iterations[ $nesting_level ] );
        unset( $this->current_priority[ $nesting_level ] );
 
        --$this->nesting_level;
 
        return $value;
    }
 
    /**
     * Calls the callback functions that have been added to an action hook.
     *
     * @since 4.7.0
     *
     * @param array $args Parameters to pass to the callback functions.
     */
    public function do_action( $args ) {
        $this->doing_action = true;
        $this->apply_filters( '', $args );
 
        // If there are recursive calls to the current action, we haven't finished it until we get to the last one.
        if ( ! $this->nesting_level ) {
            $this->doing_action = false;
        }
    }
 
    /**
     * Processes the functions hooked into the 'all' hook.
     *
     * @since 4.7.0
     *
     * @param array $args Arguments to pass to the hook callbacks. Passed by reference.
     */
    public function do_all_hook( &$args ) {
        $nesting_level                      = $this->nesting_level++;
        $this->iterations[ $nesting_level ] = $this->priorities;
 
        do {
            $priority = current( $this->iterations[ $nesting_level ] );

    if ( ! isset( $wp_filter[ $hook_name ] ) ) {
        if ( isset( $wp_filter['all'] ) ) {
            array_pop( $wp_current_filter );
        }
 
        return;
    }
 
    if ( ! isset( $wp_filter['all'] ) ) {
        $wp_current_filter[] = $hook_name;
    }
 
    if ( empty( $arg ) ) {
        $arg[] = '';
    } elseif ( is_array( $arg[0] ) && 1 === count( $arg[0] ) && isset( $arg[0][0] ) && is_object( $arg[0][0] ) ) {
        // Backward compatibility for PHP4-style passing of `array( &$this )` as action `$arg`.
        $arg[0] = $arg[0][0];
    }
 
    $wp_filter[ $hook_name ]->do_action( $arg );
 
    array_pop( $wp_current_filter );
}
 
/**
 * Calls the callback functions that have been added to an action hook, specifying arguments in an array.
 *
 * @since 2.1.0
 *
 * @see do_action() This function is identical, but the arguments passed to the
 *                  functions hooked to `$hook_name` are supplied using an array.
 *
 * @global WP_Hook[] $wp_filter         Stores all of the filters and actions.
 * @global int[]     $wp_actions        Stores the number of times each action was triggered.
 * @global string[]  $wp_current_filter Stores the list of current filters with the current one last.
 *
 * @param string $hook_name The name of the action to be executed.
 * @param array  $args      The arguments supplied to the functions hooked to `$hook_name`.
 */
function do_action_ref_array( $hook_name, $args ) {

     * @param string $before           The HTML to output before the date.
     * @param string $after            The HTML to output after the date.
     */
    echo apply_filters( 'the_weekday_date', $the_weekday_date, $before, $after );
}
 
/**
 * Fires the wp_head action.
 *
 * See {@see 'wp_head'}.
 *
 * @since 1.2.0
 */
function wp_head() {
    /**
     * Prints scripts or data in the head tag on the front end.
     *
     * @since 1.5.0
     */
    do_action( 'wp_head' );
}
 
/**
 * Fires the wp_footer action.
 *
 * See {@see 'wp_footer'}.
 *
 * @since 1.5.1
 */
function wp_footer() {
    /**
     * Prints scripts or data before the closing body tag on the front end.
     *
     * @since 1.5.1
     */
    do_action( 'wp_footer' );
}
 
/**
 * Fires the wp_body_open action.

 *
 * @since 1.3.0
 */
do_action( 'genesis_doctype' );
 
/**
 * Fires immediately after `genesis_doctype` action hook, in header.php to render the document title.
 *
 * @since 1.0.0
 */
do_action( 'genesis_title' );
 
/**
 * Fires immediately after `genesis_title` action hook, in header.php to render the meta elements.
 *
 * @since 1.0.0
 */
do_action( 'genesis_meta' );
 
wp_head(); // We need this for plugins.
?>
</head>
<?php
genesis_markup(
    [
        'open'    => '<body %s>',
        'context' => 'body',
    ]
);
 
if ( function_exists( 'wp_body_open' ) ) {
    wp_body_open();
}
 
/**
 * Fires immediately after the `wp_body_open` action hook.
 *
 * @since 1.0.0
 */
do_action( 'genesis_before' );

        extract( $wp_query->query_vars, EXTR_SKIP );
    }
 
    if ( isset( $s ) ) {
        $s = esc_attr( $s ); // @phpstan-ignore variable.undefined (It's extracted from query vars.)
    }
 
    /**
     * Fires before a template file is loaded.
     *
     * @since 6.1.0
     *
     * @param string $_template_file The full path to the template file.
     * @param bool   $load_once      Whether to require_once or require.
     * @param array  $args           Additional arguments passed to the template.
     */
    do_action( 'wp_before_load_template', $_template_file, $load_once, $args );
 
    if ( $load_once ) {
        require_once $_template_file;
    } else {
        require $_template_file;
    }
 
    /**
     * Fires after a template file is loaded.
     *
     * @since 6.1.0
     *
     * @param string $_template_file The full path to the template file.
     * @param bool   $load_once      Whether to require_once or require.
     * @param array  $args           Additional arguments passed to the template.
     */
    do_action( 'wp_after_load_template', $_template_file, $load_once, $args );
}
 
/**
 * Checks whether the template should be output buffered for enhancement.
 *
 * By default, an output buffer is only started if a {@see 'wp_template_enhancement_output_buffer'} filter has been

            continue;
        }
        if ( file_exists( $wp_stylesheet_path . '/' . $template_name ) ) {
            $candidate = $wp_stylesheet_path . '/' . $template_name;
        } elseif ( $is_child_theme && file_exists( $wp_template_path . '/' . $template_name ) ) {
            $candidate = $wp_template_path . '/' . $template_name;
        } elseif ( file_exists( ABSPATH . WPINC . '/theme-compat/' . $template_name ) ) {
            $candidate = ABSPATH . WPINC . '/theme-compat/' . $template_name;
        } else {
            continue;
        }
 
        if ( _wp_is_template_path_allowed( $candidate ) ) {
            $located = $candidate;
            break;
        }
    }
 
    if ( $load && '' !== $located ) {
        load_template( $located, $load_once, $args );
    }
 
    return $located;
}
 
/**
 * Requires the template file with WordPress environment.
 *
 * The globals are set up for the template file to ensure that the WordPress
 * environment is available from within the function. The query variables are
 * also available.
 *
 * @since 1.5.0
 * @since 5.5.0 The `$args` parameter was added.
 *
 * @global array      $posts
 * @global WP_Post    $post          Global post object.
 * @global bool       $wp_did_header
 * @global WP_Query   $wp_query      WordPress Query object.
 * @global WP_Rewrite $wp_rewrite    WordPress rewrite component.

     * Fires before the header template file is loaded.
     *
     * @since 2.1.0
     * @since 2.8.0 The `$name` parameter was added.
     * @since 5.5.0 The `$args` parameter was added.
     *
     * @param string|null $name Name of the specific header file to use. Null for the default header.
     * @param array       $args Additional arguments passed to the header template.
     */
    do_action( 'get_header', $name, $args );
 
    $templates = array();
    $name      = (string) $name;
    if ( '' !== $name ) {
        $templates[] = "header-{$name}.php";
    }
 
    $templates[] = 'header.php';
 
    if ( ! locate_template( $templates, true, true, $args ) ) {
        return false;
    }
}
 
/**
 * Loads footer template.
 *
 * Includes the footer template for a theme or if a name is specified then a
 * specialized footer will be included.
 *
 * For the parameter, if the file is called "footer-special.php" then specify
 * "special".
 *
 * @since 1.5.0
 * @since 5.5.0 A return value was added.
 * @since 5.5.0 The `$args` parameter was added.
 *
 * @param string|null $name The name of the specialized footer. Default null.
 * @param array       $args Optional. Additional arguments passed to the footer template.
 *                          Default empty array.

 * WARNING: This file is part of the core Genesis Framework. DO NOT edit this file under any circumstances.
 * Please do all modifications in the form of a child theme.
 *
 * @package Genesis\Framework
 * @author  StudioPress
 * @license GPL-2.0-or-later
 * @link    https://my.studiopress.com/themes/genesis/
 */
 
/**
 * Used to initialize the framework in the various template files.
 *
 * It pulls in all the necessary components like header and footer, the basic
 * markup structure, and hooks.
 *
 * @since 1.3.0
 */
function genesis() {
 
    get_header();
 
    /**
     * Fires after the header, before the content sidebar wrap.
     *
     * @since 1.0.0
     */
    do_action( 'genesis_before_content_sidebar_wrap' );
 
    genesis_markup(
        [
            'open'    => '<div %s>',
            'context' => 'content-sidebar-wrap',
        ]
    );
 
        /**
         * Fires before the content, after the content sidebar wrap opening markup.
         *
         * @since 1.0.0
         */

<?php
/**
 * Genesis Framework.
 *
 * WARNING: This file is part of the core Genesis Framework. DO NOT edit this file under any circumstances.
 * Please do all modifications in the form of a child theme.
 *
 * @package Genesis\Templates
 * @author  StudioPress
 * @license GPL-2.0-or-later
 * @link    https://my.studiopress.com/themes/genesis/
 */
 
// Initialize Genesis.
genesis();
 

     */
    $template   = apply_filters( 'template_include', $template );
    $is_stringy = is_string( $template ) || ( is_object( $template ) && method_exists( $template, '__toString' ) );
    $template   = $is_stringy ? realpath( (string) $template ) : null;
    if (
        is_string( $template ) &&
        ( str_ends_with( $template, '.php' ) || str_ends_with( $template, '.html' ) ) &&
        is_file( $template ) &&
        is_readable( $template )
    ) {
        /**
         * Fires immediately before including the template.
         *
         * @since 6.9.0
         *
         * @param string $template The path of the template about to be included.
         */
        do_action( 'wp_before_include_template', $template );
 
        include $template;
    } elseif ( current_user_can( 'switch_themes' ) ) {
        $theme = wp_get_theme();
        if ( $theme->errors() ) {
            wp_die( $theme->errors() );
        }
    }
    return;
}
 

<?php
/**
 * Loads the WordPress environment and template.
 *
 * @package WordPress
 */
 
if ( ! isset( $wp_did_header ) ) {
 
    $wp_did_header = true;
 
    // Load the WordPress library.
    require_once __DIR__ . '/wp-load.php';
 
    // Set up the WordPress query.
    wp();
 
    // Load the theme template.
    require_once ABSPATH . WPINC . '/template-loader.php';
 
}
 

<?php
/**
 * Front to the WordPress application. This file doesn't do anything, but loads
 * wp-blog-header.php which does and tells WordPress to load the theme.
 *
 * @package WordPress
 */
 
/**
 * Tells WordPress to load the WordPress theme and output it.
 *
 * @var bool
 */
define( 'WP_USE_THEMES', true );
 
/** Loads the WordPress Environment and Template */
require __DIR__ . '/wp-blog-header.php';