/**
     * Determines whether the query is for an existing attachment page.
     *
     * @since 3.1.0
     *
     * @param int|string|int[]|string[] $attachment Optional. Attachment ID, title, slug, or array of such
     *                                              to check against. Default empty.
     * @return bool Whether the query is for an existing attachment page.
     */
    public function is_attachment( $attachment = '' ) {
        if ( ! $this->is_attachment ) {
            return false;
        }
 
        if ( empty( $attachment ) ) {
            return true;
        }
 
        $attachment = array_map( 'strval', (array) $attachment );
 
        $post_obj = $this->get_queried_object();
        if ( ! $post_obj ) {
            return false;
        }
 
        if ( in_array( (string) $post_obj->ID, $attachment, true ) ) {
            return true;
        } elseif ( in_array( $post_obj->post_title, $attachment, true ) ) {
            return true;
        } elseif ( in_array( $post_obj->post_name, $attachment, true ) ) {
            return true;
        }
        return false;
    }
 
    /**
     * Determines whether the query is for an existing author archive page.
     *
     * If the $author parameter is specified, this function will additionally

 * the {@link https://developer.wordpress.org/themes/basics/conditional-tags/
 * Conditional Tags} article in the Theme Developer Handbook.
 *
 * @since 2.0.0
 *
 * @global WP_Query $wp_query WordPress Query object.
 *
 * @param int|string|int[]|string[] $attachment Optional. Attachment ID, title, slug, or array of such
 *                                              to check against. Default empty.
 * @return bool Whether the query is for an existing attachment page.
 */
function is_attachment( $attachment = '' ) {
    global $wp_query;
 
    if ( ! isset( $wp_query ) ) {
        _doing_it_wrong( __FUNCTION__, __( 'Conditional query tags do not work before the query is run. Before then, they always return false.' ), '3.1.0' );
        return false;
    }
 
    return $wp_query->is_attachment( $attachment );
}
 
/**
 * Determines whether the query is for an existing author archive page.
 *
 * If the $author parameter is specified, this function will additionally
 * check if the query is for one of the authors specified.
 *
 * For more information on this and similar theme functions, check out
 * the {@link https://developer.wordpress.org/themes/basics/conditional-tags/
 * Conditional Tags} article in the Theme Developer Handbook.
 *
 * @since 1.5.0
 *
 * @global WP_Query $wp_query WordPress Query object.
 *
 * @param int|string|int[]|string[] $author Optional. User ID, nickname, nicename, or array of such
 *                                          to check against. Default empty.
 * @return bool Whether the query is for an existing author archive page.
 */

        $post_format = get_post_format( $post->ID );
 
        if ( $post_format && ! is_wp_error( $post_format ) ) {
            $classes[] = 'format-' . sanitize_html_class( $post_format );
        } else {
            $classes[] = 'format-standard';
        }
    }
 
    $post_password_required = post_password_required( $post->ID );
 
    // Post requires password.
    if ( $post_password_required ) {
        $classes[] = 'post-password-required';
    } elseif ( ! empty( $post->post_password ) ) {
        $classes[] = 'post-password-protected';
    }
 
    // Post thumbnails.
    if ( current_theme_supports( 'post-thumbnails' ) && has_post_thumbnail( $post->ID ) && ! is_attachment( $post ) && ! $post_password_required ) {
        $classes[] = 'has-post-thumbnail';
    }
 
    // Sticky for Sticky Posts.
    if ( is_sticky( $post->ID ) ) {
        if ( is_home() && ! is_paged() ) {
            $classes[] = 'sticky';
        } elseif ( is_admin() ) {
            $classes[] = 'status-sticky';
        }
    }
 
    // hentry for hAtom compliance.
    $classes[] = 'hentry';
 
    // All public taxonomies.
    $taxonomies = get_taxonomies( array( 'public' => true ) );
 
    /**
     * Filters the taxonomies to generate classes for each individual term.

        $image_only = ( isset( $elements[0] ) && 'image' === $elements[0] ) && ( 1 === count( $elements ) );
 
        // Add image classes.
        if ( in_array( 'image', $this->args['show'], true ) ) {
            if ( $this->image_id ) {
                $atts['class'] .= ' has-image';
 
                if ( $image_first && ! ( ( 'single' === $this->context ) && mai_is_element_hidden( 'featured_image', $this->id ) ) ) {
                    $atts['class'] .= ' has-image-first';
                }
            }
 
            if ( $image_only ) {
                $atts['class'] .= ' has-image-only';
            }
        }
 
        // Add atts from `genesis_attributes_entry` but only when we need it.
        if ( 'post' === $this->type ) {
            $atts['class']      = mai_add_classes( implode( ' ', get_post_class() ), $atts['class'] );
            $atts['aria-label'] = $this->title_attr;
        }
 
        // Term classes.
        if ( 'term' === $this->type ) {
            $atts['class'] .= sprintf( ' term-%s type-%s %s-%s', $this->entry->term_id, $this->entry->taxonomy, $this->entry->taxonomy, $this->entry->slug );
        }
 
        // Remove duplicate classes.
        $atts['class'] = implode( ' ', array_unique( explode( ' ', $atts['class'] ) ) );
 
        // Hook.
        do_action( 'mai_before_entry', $this->entry, $this->args );
 
        // Open.
        genesis_markup(
            [
                'open'    => "<{$wrap} %s>",
                'context' => 'entry',
                'echo'    => true,

            'params'  => [
                'args' => $args,
            ],
        ]
    );
}
 
/**
 * Render a grid entry.
 *
 * @since 0.1.0
 *
 * @param WP_Post|WP_Term $entry The (post, term, user) entry object.
 * @param array           $args  The object to get the entry.
 *
 * @return  void
 */
function mai_do_entry( $entry, $args = [] ) {
    $entry = new Mai_Entry( $entry, $args );
    $entry->render();
}
 
/**
 * Get the entry index context, for use in mai_get_index().
 *
 * @since 2.34.0
 *
 * @param string $context The existing context.
 *
 * @return string
 */
function mai_get_entry_index_context( $context ) {
    switch ( $context ) {
        case 'archive':
            $return = 'entry-archive';
        break;
        case 'block':
            $return = 'entry-grid';
        break;
        default:

     *
     * @return void
     */
    public function do_grid_entries() {
        switch ( $this->args['type'] ) {
            case 'post':
                if ( $this->query_args['post_type'] ) {
                    $posts = $this->query;
                    if ( $posts->have_posts() ) {
                        while ( $posts->have_posts() ) {
                            $posts->the_post();
 
                            /**
                             * Post object.
                             *
                             * @var WP_Post $post Post object.
                             */
                            global $post;
 
                            mai_do_entry( $post, $this->args );
 
                            // Add this post to the existing post IDs.
                            self::$existing_post_ids[] = get_the_ID();
                        }
 
                        // Clear duplicate IDs.
                        self::$existing_post_ids = array_unique( self::$existing_post_ids );
                    }
                    wp_reset_postdata();
                }
                break;
 
            case 'term':
                if ( $this->query_args['taxonomy'] ) {
                    $term_query = $this->query;
 
                    if ( ! empty( $term_query->terms ) ) {
 
                        /**
                         * Terms.

            }
 
            if ( isset( $this->args['align_text'] ) && $this->args['align_text'] ) {
                $class = mai_add_classes( sprintf( 'has-text-align-%s', mai_get_align_text( $this->args['align_text'] ) ), $class );
            }
 
            printf( '<div class="%s">%s</div>', $class, mai_get_processed_content( $this->args['no_results'] ) );
            return;
        }
 
        // Grid specific classes. Didn't use mai_add_classes() because I want mai-grid first.
        $this->args['class'] = isset( $this->args['class'] ) ? $this->args['class'] : '';
        $this->args['class'] = 'mai-grid ' . $this->args['class'];
        $this->args['class'] = trim( $this->args['class'] );
 
        // Open.
        mai_do_entries_open( $this->args );
 
        // Entries.
        $this->do_grid_entries();
 
        // Close.
        mai_do_entries_close( $this->args );
    }
 
    /**
     * Gets the query.
     *
     * @since 2.4.3
     *
     * @return false|WP_Query|WP_Term_Query
     */
    public function get_query() {
        $query = false;
 
        switch ( $this->args['type'] ) {
            case 'post':
                $this->query_args = $this->get_post_query_args();
 
                if ( $this->query_args['post_type'] ) {

 * @return void
 */
function mai_do_user_grid( $args ) {
    mai_do_grid( 'user', $args );
}
 
/**
 * Renders a grid.
 *
 * @since 0.1.0
 *
 * @param string $type Grid type.
 * @param array  $args Grid args.
 *
 * @return void
 */
function mai_do_grid( $type, $args = [] ) {
    $args = array_merge( [ 'type' => $type ], $args );
    $grid = new Mai_Grid( $args );
    $grid->render();
}
 
/**
 * Get the text align value from a setting value.
 *
 * @since 0.1.0
 *
 * @param string $alignment Text alignment.
 *
 * @return string
 */
function mai_get_align_text( $alignment ) {
    switch ( $alignment ) {
        case 'start':
        case 'left':
        case 'top':
            $value = 'start';
        break;
        case 'center':
        case 'middle':

 * @param string   $content The block content.
 * @param bool     $is_preview Whether or not the block is being rendered for editing preview.
 * @param int      $post_id The current post being edited or viewed.
 * @param WP_Block $wp_block The block instance (since WP 5.5).
 * @param array    $context The block context array.
 *
 * @return void
 */
function mai_do_grid_block( $type, $attributes, $content, $is_preview, $post_id, $wp_block, $context ) {
    $args          = mai_get_grid_field_values( $type );
    $args['id']    = isset( $attributes['anchor'] ) ? sanitize_key( $attributes['anchor'] ) : '';
    $args['class'] = isset( $attributes['className'] ) ? mai_add_classes( $attributes['className'] ) : '';
 
    if ( ! empty( $attributes['align'] ) ) {
        $args['class'] = mai_add_classes( 'align' . $attributes['align'], $args['class'] );
    }
 
    $args['preview'] = $is_preview;
 
    mai_do_grid( $type, $args );
}
 

    return $values;
}
 
/**
 * Renders a post grid block.
 *
 * @since 0.1.0
 *
 * @param array    $attributes The block attributes.
 * @param string   $content The block content.
 * @param bool     $is_preview Whether or not the block is being rendered for editing preview.
 * @param int      $post_id The current post being edited or viewed.
 * @param WP_Block $wp_block The block instance (since WP 5.5).
 * @param array    $context The block context array.
 *
 * @return void
 */
function mai_do_post_grid_block( $attributes, $content, $is_preview, $post_id, $wp_block, $context ) {
    // TODO: block id?
    mai_do_grid_block( 'post', $attributes, $content, $is_preview, $post_id, $wp_block, $context );
}
 
/**
 * Renders a term grid block.
 *
 * @since 0.1.0
 *
 * @param array    $attributes The block attributes.
 * @param string   $content The block content.
 * @param bool     $is_preview Whether or not the block is being rendered for editing preview.
 * @param int      $post_id The current post being edited or viewed.
 * @param WP_Block $wp_block The block instance (since WP 5.5).
 * @param array    $context The block context array.
 *
 * @return void
 */
function mai_do_term_grid_block( $attributes, $content, $is_preview, $post_id, $wp_block, $context ) {
    // TODO: block id?
    mai_do_grid_block( 'term', $attributes, $content, $is_preview, $post_id, $wp_block, $context );
}

        return '';
    }
 
    // Find post_id if not defined.
    if ( ! $post_id ) {
        $post_id = get_the_ID();
    }
 
    // Enqueue block type assets.
    acf_enqueue_block_type_assets( $block );
 
    // Ensure block ID is prefixed for render.
    $block['id'] = acf_ensure_block_id_prefix( $block['id'] );
 
    // Setup postdata allowing get_field() to work.
    acf_setup_meta( $block['data'], $block['id'], true );
 
    // Call render_callback.
    if ( is_callable( $block['render_callback'] ) ) {
        call_user_func( $block['render_callback'], $block, $content, $is_preview, $post_id, $wp_block, $context );
 
        // Or include template.
    } elseif ( $block['render_template'] ) {
        do_action( 'acf_block_render_template', $block, $content, $is_preview, $post_id, $wp_block, $context );
    }
 
    // Reset postdata.
    acf_reset_meta( $block['id'] );
}
 
/**
 * Locate and include an ACF block's template.
 *
 * @since   6.0.4
 *
 * @param   array $block The block props.
 */
function acf_block_render_template( $block, $content, $is_preview, $post_id, $wp_block, $context ) {
    // Locate template.
    if ( isset( $block['path'] ) && file_exists( $block['path'] . '/' . $block['render_template'] ) ) {

    if ( $form ) {
        // Load the block form since we're in edit mode.
        // Set flag for post REST cleanup of media enqueue count during preloads.
        acf_set_data( 'acf_did_render_block_form', true );
 
        $block = acf_prepare_block( $attributes );
        acf_setup_meta( $block['data'], $block['id'], true );
        $fields = acf_get_block_fields( $block );
        if ( $fields ) {
            acf_prefix_fields( $fields, "acf-{$block['id']}" );
 
            echo '<div class="acf-block-fields acf-fields">';
            acf_render_fields( $fields, $block['id'], 'div', 'field' );
            echo '</div>';
        } else {
            echo acf_get_empty_block_form_html( $attributes['name'] ); //phpcs:ignore -- escaped in function.
        }
    } else {
        // Capture block render output.
        acf_render_block( $attributes, $content, $is_preview, $post_id, $wp_block, $context );
    }
 
    $html = ob_get_clean();
    $html = is_string( $html ) ? $html : '';
 
    // Replace <InnerBlocks /> placeholder on front-end, or if we're rendering an ACF block inside another ACF block template.
    if ( ! $is_preview || doing_action( 'acf_block_render_template' ) ) {
        // Escape "$" character to avoid "capture group" interpretation.
        $content = str_replace( '$', '\$', $content );
 
        // Wrap content in our acf-inner-container wrapper if necessary.
        if ( $wp_block && $wp_block->block_type->acf_block_version > 1 && apply_filters( 'acf/blocks/wrap_frontend_innerblocks', true, $attributes['name'] ) ) {
            // Check for a class (or className) provided in the template to become the InnerBlocks wrapper class.
            $matches = array();
            if ( preg_match( '/<InnerBlocks(?:[^<]+?)(?:class|className)=(?:["\']\W+\s*(?:\w+)\()?["\']([^\'"]+)[\'"]/', $html, $matches ) ) {
                $class = isset( $matches[1] ) ? $matches[1] : 'acf-innerblocks-container';
            } else {
                $class = 'acf-innerblocks-container';
            }
            $content = '<div class="' . $class . '">' . $content . '</div>';

 * @param   string   $content    The block content.
 * @param   WP_Block $wp_block   The block instance (since WP 5.5).
 * @return  string The block HTML.
 */
function acf_render_block_callback( $attributes, $content = '', $wp_block = null ) {
    $is_preview = false;
    $post_id    = get_the_ID();
 
    // Set preview flag to true when rendering for the block editor.
    if ( is_admin() && acf_is_block_editor() ) {
        $is_preview = true;
    }
 
    // If ACF's block save method hasn't been called yet, try to initialize a default block.
    if ( empty( $attributes['name'] ) && ! empty( $wp_block->name ) ) {
        $attributes['name'] = $wp_block->name;
    }
 
    // Return rendered block HTML.
    return acf_rendered_block( $attributes, $content, $is_preview, $post_id, $wp_block );
}
 
/**
 * Returns the rendered block HTML.
 *
 * @date    28/2/19
 * @since   5.7.13
 *
 * @param   array    $attributes The block attributes.
 * @param   string   $content    The block content.
 * @param   boolean  $is_preview Whether or not the block is being rendered for editing preview.
 * @param   integer  $post_id    The current post being edited or viewed.
 * @param   WP_Block $wp_block   The block instance (since WP 5.5).
 * @param   array    $context    The block context array.
 * @return  string   The block HTML.
 */
function acf_rendered_block( $attributes, $content = '', $is_preview = false, $post_id = 0, $wp_block = null, $context = false ) {
    $mode = isset( $attributes['mode'] ) ? $attributes['mode'] : 'auto';
    $form = ( 'edit' === $mode && $is_preview );
 

                    }
 
                    ++$index;
                }
            }
        }
 
        if ( ! empty( $computed_attributes ) && ! empty( $block_content ) ) {
            foreach ( $computed_attributes as $attribute_name => $source_value ) {
                $block_content = $this->replace_html( $block_content, $attribute_name, $source_value );
            }
        }
 
        if ( $is_dynamic ) {
            $global_post = $post;
            $parent      = WP_Block_Supports::$block_to_render;
 
            WP_Block_Supports::$block_to_render = $this->parsed_block;
 
            $block_content = (string) call_user_func( $this->block_type->render_callback, $this->attributes, $block_content, $this );
 
            WP_Block_Supports::$block_to_render = $parent;
 
            $post = $global_post;
        }
 
        if ( ( ! empty( $this->block_type->script_handles ) ) ) {
            foreach ( $this->block_type->script_handles as $script_handle ) {
                wp_enqueue_script( $script_handle );
            }
        }
 
        if ( ! empty( $this->block_type->view_script_handles ) ) {
            foreach ( $this->block_type->view_script_handles as $view_script_handle ) {
                wp_enqueue_script( $view_script_handle );
            }
        }
 
        if ( ! empty( $this->block_type->view_script_module_ids ) ) {
            foreach ( $this->block_type->view_script_module_ids as $view_script_module_id ) {

                    $block_content .= $chunk;
                } else {
                    $inner_block  = $this->inner_blocks[ $index ];
                    $parent_block = $this;
 
                    /** This filter is documented in wp-includes/blocks.php */
                    $pre_render = apply_filters( 'pre_render_block', null, $inner_block->parsed_block, $parent_block );
 
                    if ( ! is_null( $pre_render ) ) {
                        $block_content .= $pre_render;
                    } else {
                        $source_block = $inner_block->parsed_block;
 
                        /** This filter is documented in wp-includes/blocks.php */
                        $inner_block->parsed_block = apply_filters( 'render_block_data', $inner_block->parsed_block, $source_block, $parent_block );
 
                        /** This filter is documented in wp-includes/blocks.php */
                        $inner_block->context = apply_filters( 'render_block_context', $inner_block->context, $inner_block->parsed_block, $parent_block );
 
                        $block_content .= $inner_block->render();
                    }
 
                    ++$index;
                }
            }
        }
 
        if ( ! empty( $computed_attributes ) && ! empty( $block_content ) ) {
            foreach ( $computed_attributes as $attribute_name => $source_value ) {
                $block_content = $this->replace_html( $block_content, $attribute_name, $source_value );
            }
        }
 
        if ( $is_dynamic ) {
            $global_post = $post;
            $parent      = WP_Block_Supports::$block_to_render;
 
            WP_Block_Supports::$block_to_render = $this->parsed_block;
 
            $block_content = (string) call_user_func( $this->block_type->render_callback, $this->attributes, $block_content, $this );

         * it should be included to consistently fulfill the expectation.
         */
        $context['postType'] = $post->post_type;
    }
 
    /**
     * Filters the default context provided to a rendered block.
     *
     * @since 5.5.0
     * @since 5.9.0 The `$parent_block` parameter was added.
     *
     * @param array         $context      Default context.
     * @param array         $parsed_block Block being rendered, filtered by `render_block_data`.
     * @param WP_Block|null $parent_block If this is a nested block, a reference to the parent block.
     */
    $context = apply_filters( 'render_block_context', $context, $parsed_block, $parent_block );
 
    $block = new WP_Block( $parsed_block, $context );
 
    return $block->render();
}
 
/**
 * Parses blocks out of a content string.
 *
 * @since 5.0.0
 *
 * @param string $content Post content.
 * @return array[] Array of parsed block objects.
 */
function parse_blocks( $content ) {
    /**
     * Filter to allow plugins to replace the server-side block parser.
     *
     * @since 5.0.0
     *
     * @param string $parser_class Name of block parser class.
     */
    $parser_class = apply_filters( 'block_parser_class', 'WP_Block_Parser' );
 

    $parser_class = apply_filters( 'block_parser_class', 'WP_Block_Parser' );
 
    $parser = new $parser_class();
    return $parser->parse( $content );
}
 
/**
 * Parses dynamic blocks out of `post_content` and re-renders them.
 *
 * @since 5.0.0
 *
 * @param string $content Post content.
 * @return string Updated post content.
 */
function do_blocks( $content ) {
    $blocks = parse_blocks( $content );
    $output = '';
 
    foreach ( $blocks as $block ) {
        $output .= render_block( $block );
    }
 
    // If there are blocks in this content, we shouldn't run wpautop() on it later.
    $priority = has_filter( 'the_content', 'wpautop' );
    if ( false !== $priority && doing_filter( 'the_content' ) && has_blocks( $content ) ) {
        remove_filter( 'the_content', 'wpautop', $priority );
        add_filter( 'the_content', '_restore_wpautop_hook', $priority + 1 );
    }
 
    return $output;
}
 
/**
 * If do_blocks() needs to remove wpautop() from the `the_content` filter, this re-adds it afterwards,
 * for subsequent `the_content` usage.
 *
 * @since 5.0.0
 * @access private
 *
 * @param string $content The post content running through this filter.

<?php
 
// Prevent direct file access.
defined( 'ABSPATH' ) || die;
 
/**
 * Gets processed content.
 *
 * @since 0.1.0
 *
 * @param string $content
 *
 * @return string
 */
function maipub_get_processed_ad_content( $content ) {
    return do_blocks( $content );
}
 
/**
 * Get processed content.
 * Take from mai_get_processed_content() in Mai Engine.
 *
 * @since 0.1.0
 *
 * @return string
 */
function maipub_get_processed_content( $content ) {
    if ( function_exists( 'mai_get_processed_content' ) ) {
        return mai_get_processed_content( $content );
    }
 
    /**
     * Embed.
     *
     * @var WP_Embed $wp_embed Embed object.
     */
    global $wp_embed;
 
    $blocks  = has_blocks( $content );
    $content = $wp_embed->autoembed( $content );            // WP runs priority 8.

 *
 * @return array
 */
function maipub_validate_ad_conditions_global( $args ) {
    // Parse.
    $args = wp_parse_args( $args, [
        'id'       => '',
        'slug'     => '',
        'location' => '',
        'content'  => '',
        'header'   => '',
        'footer'   => '',
    ] );
 
    // Sanitize.
    $args = [
        'id'       => absint( $args['id'] ),
        'slug'     => sanitize_key( $args['slug'] ),
        'location' => esc_html( $args['location'] ),
        'content'  => trim( maipub_get_processed_ad_content( $args['content'] ) ),
        'header'   => $args['header'],
        'footer'   => $args['footer'],
    ];
 
    return $args;
}
 
/**
 * Validates single content args.
 * In content, recipe, etc. are checked directly in the dom.
 *
 * @since 0.13.0
 *
 * @param array $args The ad args.
 *
 * @return array
 */
function maipub_validate_ad_conditions_single( $args ) {
    if ( ! maipub_is_singular() ) {
        return [];

function maipub_validate_ad_conditions( $args, $type ) {
    $valid = [];
 
    // Bail if no id, content, and location.
    if ( ! ( $args['id'] && $args['location'] && $args['content'] ) ) {
        return $valid;
    }
 
    // Set variables.
    $locations = maipub_get_locations();
 
    // Bail if no location hook. Only check isset for location since 'content' has no hook.
    if ( ! isset( $locations[ $args['location'] ] ) ) {
        return $valid;
    }
 
    // Validate by type.
    switch ( $type ) {
        case 'global':
            $valid = maipub_validate_ad_conditions_global( $args );
            break;
 
        case 'single':
            $valid = maipub_validate_ad_conditions_single( $args );
            break;
 
        case 'archive':
            $valid = maipub_validate_ad_conditions_archive( $args );
            break;
    }
 
    return $valid;
}
 
/**
 * Validate global content args.
 *
 * @since 0.13.0
 *
 * @param array $args The ad args.

    if ( ! is_null( $ads ) ) {
        return $ads;
    }
 
    $ads = [];
 
    // Get ad data from location settings.
    $data = maipub_get_page_ads_data();
 
    // Bail if no actual values.
    if ( ! array_filter( array_values( $data ) ) ) {
        return $ads;
    }
 
    // Loop through each type.
    foreach ( $data as $type => $items ) {
        // Loop through each item.
        foreach ( $items as $args ) {
            // Validate.
            $args = maipub_validate_ad_conditions( $args, $type );
 
            // Bail if not valid args.
            if ( ! $args ) {
                continue;
            }
 
            // Set location targets. Manually added ads are handled in `class-display.php`.
            $args['content'] = maipub_add_location_attributes( $args['content'], $args['location'] );
 
            // Add to ads.
            $ads[] = $args;
        }
    }
 
    // Allow filtering.
    $ads = apply_filters( 'mai_publisher_page_ads', $ads );
 
    return $ads;
}
 

        add_action( 'template_redirect',                   [ $this, 'get_page_ads' ] );
        add_filter( 'mai_grid_args',                       [ $this, 'add_grid_args' ] );
        add_filter( 'genesis_attr_entries-wrap',           [ $this, 'add_attributes' ], 10, 3 );
        add_filter( 'genesis_markup_entries_content',      [ $this, 'add_css' ], 10, 2 );
        add_filter( 'genesis_markup_entries-wrap_content', [ $this, 'add_ads' ], 10, 2 );
        add_action( 'mai_after_entry',                     [ $this, 'increment_index' ], 10, 2 );
        add_action( 'acf/init',                            [ $this, 'register_grid_field_group' ] );
        // add_action( 'admin_footer',                        [ $this, 'settings_generate_file' ] );
        // add_action( 'customize_save_after',                [ $this, 'customizer_generate_file' ] );
    }
 
    /**
     * Do entries relate things.
     *
     * @since 1.2.0
     *
     * @return void
     */
    function get_page_ads() {
        $this->page_ads = maipub_get_page_ads();
    }
 
    /**
     * Adds custom grid fields as args.
     *
     * @since 1.1.0
     *
     * @param array $args The existing grid args.
     *
     * @return array
     */
    function add_grid_args( $args ) {
        // Get the ad clone field data.
        $ad = get_field( 'maipub_ad_unit' );
 
        // Set new args.
        $args['ad_unit_id']            = isset( $ad['id'] ) ? $ad['id'] : '';
        $args['ad_unit_content_count'] = array_map( 'absint', array_filter( explode( ',', (string) isset( $ad['content_count'] ) ? $ad['content_count'] : '' ) ) );
        $args['ad_unit_content_item']  = isset( $ad['content_item'] ) ? $ad['content_item'] : '';
        $args['ad_unit_type']          = isset( $ad['type'] ) ? $ad['type'] : '';

 
        $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 ) {

<?php
/**
 * Loads the correct template based on the visitor's url
 *
 * @package WordPress
 */
if ( wp_using_themes() ) {
    /**
     * Fires before determining which template to load.
     *
     * @since 1.5.0
     */
    do_action( 'template_redirect' );
}
 
/**
 * Filters whether to allow 'HEAD' requests to generate content.
 *
 * Provides a significant performance bump by exiting before the page
 * content loads for 'HEAD' requests. See #14348.
 *
 * @since 3.5.0
 *
 * @param bool $exit Whether to exit without generating any content for 'HEAD' requests. Default true.
 */
if ( 'HEAD' === $_SERVER['REQUEST_METHOD'] && apply_filters( 'exit_on_http_head', true ) ) {
    exit;
}
 
// Process feeds and trackbacks even if not using themes.
if ( is_robots() ) {
    /**
     * Fired when the template loader determines a robots.txt request.
     *
     * @since 2.1.0
     */
    do_action( 'do_robots' );
    return;
} elseif ( is_favicon() ) {
    /**

<?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';