*
     * @param  string  $__path
     * @param  array  $__data
     * @return string
     */
    protected function evaluatePath($__path, $__data)
    {
        $obLevel = ob_get_level();
 
        ob_start();
 
        extract($__data, EXTR_SKIP);
 
        // We'll evaluate the contents of the view inside a try/catch block so we can
        // flush out any stray output that might get out before an error occurs or
        // an exception is thrown. This prevents any partial views from leaking.
        try {
            include $__path;
        } catch (Exception $e) {
            $this->handleViewException($e, $obLevel);
        } catch (Throwable $e) {
            $this->handleViewException(new FatalThrowableError($e), $obLevel);
        }
 
        return ltrim(ob_get_clean());
    }
 
    /**
     * Handle a view exception.
     *
     * @param  \Exception  $e
     * @param  int  $obLevel
     * @return void
     *
     * @throws \Exception
     */
    protected function handleViewException(Exception $e, $obLevel)
    {
        while (ob_get_level() > $obLevel) {
            ob_end_clean();

     * Render the widget output on the frontend.
     *
     * Written in PHP and used to generate the final HTML.
     *
     * @since  1.0.0
     *
     * @access protected
     */
    protected function render(): void
    {
        $attributes = $this->get_settings_for_display();
 
        $items = [];
        foreach (Arr::get($attributes, 'items', []) as $key => $item) {
            $items[] = $item;
        }
 
        usort($items, function($a, $b) {
            return Arr::get($a, 'points') < Arr::get($b, 'points');
        });
 
        $data = [
            'name'         => Arr::get($attributes, 'name'),
            'promotion'         => Arr::get($attributes, 'promotion') == 'yes',
            'degradation'         => Arr::get($attributes, 'degradation') == 'yes',
            'items'         => $items,
        ];
 
        $view = themeInclude('widgets.standings');
        bladerunner($view, $data);
    }
}

     * Render the widget output on the frontend.
     *
     * Written in PHP and used to generate the final HTML.
     *
     * @since  1.0.0
     *
     * @access protected
     */
    protected function render(): void
    {
        $attributes = $this->get_settings_for_display();
 
        $items = [];
        foreach (Arr::get($attributes, 'items', []) as $key => $item) {
            $items[] = $item;
        }
 
        usort($items, function($a, $b) {
            return Arr::get($a, 'points') < Arr::get($b, 'points');
        });
 
        $data = [
            'name'         => Arr::get($attributes, 'name'),
            'promotion'         => Arr::get($attributes, 'promotion') == 'yes',
            'degradation'         => Arr::get($attributes, 'degradation') == 'yes',
            'items'         => $items,
        ];
 
        $view = themeInclude('widgets.standings');
        bladerunner($view, $data);
    }
}

    /**
     * Render element in static mode.
     *
     * If not inherent will call the base render.
     */
    protected function render_static() {
        $this->render();
    }
 
    /**
     * Determine the render logic.
     */
    protected function render_by_mode() {
        if ( Plugin::$instance->frontend->is_static_render_mode() ) {
            $this->render_static();
 
            return;
        }
 
        $this->render();
    }
 
    /**
     * Print content template.
     *
     * Used to generate the content template on the editor, using a
     * Backbone JavaScript template.
     *
     * @access protected
     * @since 2.0.0
     *
     * @param string $template_content Template content.
     */
    protected function print_template_content( $template_content ) {
        echo $template_content; // phpcs:ignore WordPress.Security.EscapeOutput.OutputNotEscaped
    }
 
    /**
     * Render element output in the editor.
     *

    public function render_content() {
        /**
         * Before widget render content.
         *
         * Fires before Elementor widget is being rendered.
         *
         * @since 1.0.0
         *
         * @param Widget_Base $this The current widget.
         */
        do_action( 'elementor/widget/before_render_content', $this );
 
        ob_start();
 
        $skin = $this->get_current_skin();
        if ( $skin ) {
            $skin->set_parent( $this );
            $skin->render_by_mode();
        } else {
            $this->render_by_mode();
        }
 
        $widget_content = ob_get_clean();
 
        if ( empty( $widget_content ) ) {
            return;
        }
        ?>
        <div class="elementor-widget-container">
            <?php
            if ( $this->is_widget_first_render( $this->get_group_name() ) ) {
                $this->register_runtime_widget( $this->get_group_name() );
            }
 
            // $this->print_widget_css();
 
            // get_name
 
            /**
             * Render widget content.

            ob_start();
 
            $this->render_content();
 
            $data['htmlCache'] = ob_get_clean();
        }
 
        return $data;
    }
 
    /**
     * Print widget content.
     *
     * Output the widget final HTML on the frontend.
     *
     * @since 1.0.0
     * @access protected
     */
    protected function print_content() {
        $this->render_content();
    }
 
    /**
     * Print a setting content without escaping.
     *
     * Script tags are allowed on frontend according to the WP theme securing policy.
     *
     * @param string $setting
     * @param null $repeater_name
     * @param null $index
     */
    final public function print_unescaped_setting( $setting, $repeater_name = null, $index = null ) {
        if ( $repeater_name ) {
            $repeater = $this->get_settings_for_display( $repeater_name );
            $output = $repeater[ $index ][ $setting ];
        } else {
            $output = $this->get_settings_for_display( $setting );
        }
 
        echo $output; // phpcs:ignore WordPress.Security.EscapeOutput.OutputNotEscaped

         * Before frontend element render.
         *
         * Fires before Elementor element is rendered in the frontend.
         *
         * The dynamic portion of the hook name, `$element_type`, refers to the element type.
         *
         * @since 1.0.0
         *
         * @param Element_Base $this The element.
         */
        do_action( "elementor/frontend/{$element_type}/before_render", $this );
 
        ob_start();
 
        if ( $this->has_own_method( '_print_content', self::class ) ) {
            Plugin::$instance->modules_manager->get_modules( 'dev-tools' )->deprecation->deprecated_function( '_print_content', '3.1.0', __CLASS__ . '::print_content()' );
 
            $this->_print_content();
        } else {
            $this->print_content();
        }
 
        $content = ob_get_clean();
 
        $should_render = ( ! empty( $content ) || $this->should_print_empty() );
 
        /**
         * Should the element be rendered for frontend
         *
         * Filters if the element should be rendered on frontend.
         *
         * @since 2.3.3
         *
         * @param bool true The element.
         * @param Element_Base $this The element.
         */
        $should_render = apply_filters( "elementor/frontend/{$element_type}/should_render", $should_render, $this );
 
        if ( $should_render ) {
            if ( $this->has_own_method( '_add_render_attributes', self::class ) ) {

     * @access protected
     * @deprecated 3.1.0 Use `print_content()` method instead.
     */
    protected function _print_content() {
        Plugin::$instance->modules_manager->get_modules( 'dev-tools' )->deprecation->deprecated_function( __METHOD__, '3.1.0', 'print_content()' );
 
        $this->print_content();
    }
 
    /**
     * Print element content.
     *
     * Output the element final HTML on the frontend.
     *
     * @since 3.1.0
     * @access protected
     */
    protected function print_content() {
        foreach ( $this->get_children() as $child ) {
            $child->print_element();
        }
    }
 
    /**
     * Get initial config.
     *
     * Retrieve the current element initial configuration.
     *
     * Adds more configuration on top of the controls list and the tabs assigned
     * to the control. This method also adds element name, type, icon and more.
     *
     * @since 2.9.0
     * @access protected
     *
     * @return array The initial config.
     */
    protected function get_initial_config() {
        $config = [
            'name' => $this->get_name(),
            'elType' => $this->get_type(),

         * Before frontend element render.
         *
         * Fires before Elementor element is rendered in the frontend.
         *
         * The dynamic portion of the hook name, `$element_type`, refers to the element type.
         *
         * @since 1.0.0
         *
         * @param Element_Base $this The element.
         */
        do_action( "elementor/frontend/{$element_type}/before_render", $this );
 
        ob_start();
 
        if ( $this->has_own_method( '_print_content', self::class ) ) {
            Plugin::$instance->modules_manager->get_modules( 'dev-tools' )->deprecation->deprecated_function( '_print_content', '3.1.0', __CLASS__ . '::print_content()' );
 
            $this->_print_content();
        } else {
            $this->print_content();
        }
 
        $content = ob_get_clean();
 
        $should_render = ( ! empty( $content ) || $this->should_print_empty() );
 
        /**
         * Should the element be rendered for frontend
         *
         * Filters if the element should be rendered on frontend.
         *
         * @since 2.3.3
         *
         * @param bool true The element.
         * @param Element_Base $this The element.
         */
        $should_render = apply_filters( "elementor/frontend/{$element_type}/should_render", $should_render, $this );
 
        if ( $should_render ) {
            if ( $this->has_own_method( '_add_render_attributes', self::class ) ) {

     * @access protected
     * @deprecated 3.1.0 Use `print_content()` method instead.
     */
    protected function _print_content() {
        Plugin::$instance->modules_manager->get_modules( 'dev-tools' )->deprecation->deprecated_function( __METHOD__, '3.1.0', 'print_content()' );
 
        $this->print_content();
    }
 
    /**
     * Print element content.
     *
     * Output the element final HTML on the frontend.
     *
     * @since 3.1.0
     * @access protected
     */
    protected function print_content() {
        foreach ( $this->get_children() as $child ) {
            $child->print_element();
        }
    }
 
    /**
     * Get initial config.
     *
     * Retrieve the current element initial configuration.
     *
     * Adds more configuration on top of the controls list and the tabs assigned
     * to the control. This method also adds element name, type, icon and more.
     *
     * @since 2.9.0
     * @access protected
     *
     * @return array The initial config.
     */
    protected function get_initial_config() {
        $config = [
            'name' => $this->get_name(),
            'elType' => $this->get_type(),

         * Before frontend element render.
         *
         * Fires before Elementor element is rendered in the frontend.
         *
         * The dynamic portion of the hook name, `$element_type`, refers to the element type.
         *
         * @since 1.0.0
         *
         * @param Element_Base $this The element.
         */
        do_action( "elementor/frontend/{$element_type}/before_render", $this );
 
        ob_start();
 
        if ( $this->has_own_method( '_print_content', self::class ) ) {
            Plugin::$instance->modules_manager->get_modules( 'dev-tools' )->deprecation->deprecated_function( '_print_content', '3.1.0', __CLASS__ . '::print_content()' );
 
            $this->_print_content();
        } else {
            $this->print_content();
        }
 
        $content = ob_get_clean();
 
        $should_render = ( ! empty( $content ) || $this->should_print_empty() );
 
        /**
         * Should the element be rendered for frontend
         *
         * Filters if the element should be rendered on frontend.
         *
         * @since 2.3.3
         *
         * @param bool true The element.
         * @param Element_Base $this The element.
         */
        $should_render = apply_filters( "elementor/frontend/{$element_type}/should_render", $should_render, $this );
 
        if ( $should_render ) {
            if ( $this->has_own_method( '_add_render_attributes', self::class ) ) {

            echo do_shortcode( $cached_data['content'] ); // phpcs:ignore WordPress.Security.EscapeOutput.OutputNotEscaped
        }
    }
 
    protected function do_print_elements( $elements_data ) {
        // Collect all data updaters that should be updated on runtime.
        $runtime_elements_iteration_actions = $this->get_runtime_elements_iteration_actions();
 
        if ( $runtime_elements_iteration_actions ) {
            $this->iterate_elements( $elements_data, $runtime_elements_iteration_actions, 'render' );
        }
 
        foreach ( $elements_data as $element_data ) {
            $element = Plugin::$instance->elements_manager->create_element_instance( $element_data );
 
            if ( ! $element ) {
                continue;
            }
 
            $element->print_element();
        }
    }
 
    public function set_document_cache( $value ) {
        $expiration_hours = get_option( 'elementor_element_cache_ttl', '' );
 
        if ( empty( $expiration_hours ) || ! is_numeric( $expiration_hours ) ) {
            $expiration_hours = '24';
        }
 
        $expiration_hours = absint( $expiration_hours );
 
        $expiration = '+' . $expiration_hours . ' hours';
 
        $data = [
            'timeout' => strtotime( $expiration, current_time( 'timestamp' ) ),
            'value' => $value,
        ];
 
        $this->update_json_meta( static::CACHE_META_KEY, $data );

 
    /**
     * @since 2.0.4
     * @access protected
     *
     * @param $settings
     */
    protected function save_settings( $settings ) {
        $page_settings_manager = SettingsManager::get_settings_managers( 'page' );
        $page_settings_manager->ajax_before_save_settings( $settings, $this->post->ID );
        $page_settings_manager->save_settings( $settings, $this->post->ID );
    }
 
    /**
     * @since 2.1.3
     * @access protected
     */
    protected function print_elements( $elements_data ) {
        if ( ! Plugin::$instance->experiments->is_feature_active( 'e_element_cache' ) ) {
            $this->do_print_elements( $elements_data );
 
            return;
        }
 
        $cached_data = $this->get_document_cache();
 
        if ( false === $cached_data ) {
            add_filter( 'elementor/element/should_render_shortcode', '__return_true' );
 
            $scripts_to_queue = [];
            $styles_to_queue = [];
 
            global $wp_scripts, $wp_styles;
 
            $should_store_scripts = $wp_scripts instanceof \WP_Scripts && $wp_styles instanceof \WP_Styles;
            if ( $should_store_scripts ) {
                $scripts_ignored = $wp_scripts->queue;
                $styles_ignored = $wp_styles->queue;
            }
 

            ],
        ];
 
        return Plugin::$instance->experiments->is_feature_active( 'container' )
            ? $this->get_container_elements_data( $converted_blocks )
            : $this->get_sections_elements_data( $converted_blocks );
    }
 
    /**
     * @since 2.1.3
     * @access public
     */
    public function print_elements_with_wrapper( $elements_data = null ) {
        if ( ! $elements_data ) {
            $elements_data = $this->get_elements_data();
        }
 
        ?>
        <div <?php Utils::print_html_attributes( $this->get_container_attributes() ); ?>>
                <?php $this->print_elements( $elements_data ); ?>
        </div>
        <?php
    }
 
    /**
     * @since 2.0.0
     * @access public
     */
    public function get_css_wrapper_selector() {
        return '';
    }
 
    /**
     * @since 2.0.0
     * @access public
     */
    public function get_panel_page_settings() {
        return [
            'title' => sprintf(
                /* translators: %s: Document title. */

        // Handle JS and Customizer requests, with CSS inline.
        if ( is_customize_preview() || wp_doing_ajax() ) {
            $with_css = true;
        }
 
        /**
         * Builder Content - With CSS
         *
         * Allows overriding the `$with_css` parameter which is a factor in determining whether to print the document's
         * CSS and font links inline in a `style` tag above the document's markup.
         *
         * @param $with_css boolean
         */
        $with_css = apply_filters( 'elementor/frontend/builder_content/before_print_css', $with_css );
 
        if ( ! empty( $css_file ) && $with_css ) {
            $css_file->print_css();
        }
 
        $document->print_elements_with_wrapper( $data );
 
        $content = ob_get_clean();
 
        $content = $this->process_more_tag( $content );
 
        /**
         * Frontend content.
         *
         * Filters the content in the frontend.
         *
         * @since 1.0.0
         *
         * @param string $content The content.
         */
        $content = apply_filters( 'elementor/frontend/the_content', $content );
 
        if ( ! empty( $content ) ) {
            $this->_has_elementor_in_page = true;
        }
 

     *
     * @since 1.0.0
     * @access public
     *
     * @param string $content The post content.
     *
     * @return string The post content.
     */
    public function apply_builder_in_content( $content ) {
        $this->restore_content_filters();
 
        if ( Plugin::$instance->preview->is_preview_mode() || $this->_is_excerpt ) {
            return $content;
        }
 
        // Remove the filter itself in order to allow other `the_content` in the elements
        $this->remove_content_filter();
 
        $post_id = get_the_ID();
        $builder_content = $this->get_builder_content( $post_id );
 
        if ( ! empty( $builder_content ) ) {
            $content = $builder_content;
            $this->remove_content_filters();
        }
 
        // Add the filter again for other `the_content` calls
        $this->add_content_filter();
 
        return $content;
    }
 
    /**
     * Retrieve builder content.
     *
     * Used to render and return the post content with all the Elementor elements.
     *
     * Note that this method is an internal method, please use `get_builder_content_for_display()`.
     *
     * @since 1.0.0

 
        $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`.

        }
        if ( $form = $this->maybe_show_password_form() ) {
            return $form;
        }
        if ( $len == -1 && $page == 0 && $this->___content ) {
            return $this->___content;
        }
        $content = $this->post_content;
        if ( $len > 0 ) {
            $content = wp_trim_words($content, $len);
        }
        if ( $page ) {
            $contents = explode('<!--nextpage-->', $content);
            $page--;
            if ( count($contents) > $page ) {
                $content = $contents[$page];
            }
        }
        $content = $this->content_handle_no_teaser_block( $content );
        $content = apply_filters('the_content', ($content));
        if ( $len == -1 && $page == 0 ) {
            $this->___content = $content;
        }
        return $content;
    }
 
    /**
     * Handles for an circumstance with the Block editor where a "more" block has an option to
     * "Hide the excerpt on the full content page" which hides everything prior to the inserted
     * "more" block
     * @ticket #2218
     * @param string $content
     * @return string
     */
    protected function content_handle_no_teaser_block( $content ) {
        if ( (strpos($content, 'noTeaser:true') !== false || strpos($content, '"noTeaser":true') !== false) && strpos($content, '<!-- /wp:more -->') !== false) {
            $arr = explode('<!-- /wp:more -->', $content);
            return trim($arr[1]);
        }
        return $content;

     * @return mixed
     */
    public function __call( $field, $args ) {
        return $this->__get($field);
    }
 
    /**
     * This is helpful for twig to return properties and methods see: https://github.com/fabpot/Twig/issues/2
     *
     * @return mixed
     */
    public function __get( $field ) {
        if ( property_exists($this, $field) ) {
            return $this->$field;
        }
        if ( method_exists($this, 'meta') && $meta_value = $this->meta($field) ) {
            return $this->$field = $meta_value;
        }
        if ( method_exists($this, $field) ) {
            return $this->$field = $this->$field();
        }
        return $this->$field = false;
    }
 
    /**
     * Takes an array or object and adds the properties to the parent object
     * @example
     * ```php
     * $data = array('airplane' => '757-200', 'flight' => '5316');
     * $post = new Timber\Post()
     * $post->import(data);
     * echo $post->airplane; //757-200
     * ```
     * @param array|object $info an object or array you want to grab data from to attach to the Timber object
     */
    public function import( $info, $force = false ) {
        if ( is_object($info) ) {
            $info = get_object_vars($info);
        }
        if ( is_array($info) ) {

     * $post = new Timber\Post();
     * $other_post = new Timber\Post($random_post_id);
     * ```
     * @param mixed $pid
     */
    public function __construct( $pid = null ) {
        $pid = $this->determine_id($pid);
        $this->init($pid);
    }
 
    /**
     * This is helpful for twig to return properties and methods see: https://github.com/fabpot/Twig/issues/2
     * This is also here to ensure that {{ post.class }} remains usable
     * @return mixed
     */
    public function __get( $field ) {
        if ( 'class' === $field ) {
            return $this->css_class();
        }
        return parent::__get($field);
    }
 
    /**
     * This is helpful for twig to return properties and methods see: https://github.com/fabpot/Twig/issues/2
     * This is also here to ensure that {{ post.class }} remains usable
     * @return mixed
     */
    public function __call( $field, $args ) {
        if ( 'class' === $field ) {
            $class = isset($args[0]) ? $args[0] : '';
            return $this->css_class($class);
        }
 
        return parent::__call($field, $args);
    }
 
    /**
     * Determine whether or not an admin/editor is looking at the post in "preview mode" via the
     * WordPress admin
     * @internal

<?php $__env->startSection('content'); ?>
    <?php echo $page->content; ?>
 
<?php $__env->stopSection(); ?>
 
<?php echo $__env->make(@themeInclude('layouts.default'), \Illuminate\Support\Arr::except(get_defined_vars(), ['__data', '__path']))->render(); ?><?php /**PATH /home/forge/acceptance.fcstraat.com/releases/20241022081023/resources/views/fcstraat/default.blade.php ENDPATH**/ ?>

    /**
     * Get the evaluated contents of the view at the given path.
     *
     * @param  string  $__path
     * @param  array  $__data
     * @return string
     */
    protected function evaluatePath($__path, $__data)
    {
        $obLevel = ob_get_level();
 
        ob_start();
 
        extract($__data, EXTR_SKIP);
 
        // We'll evaluate the contents of the view inside a try/catch block so we can
        // flush out any stray output that might get out before an error occurs or
        // an exception is thrown. This prevents any partial views from leaking.
        try {
            include $__path;
        } catch (Exception $e) {
            $this->handleViewException($e, $obLevel);
        } catch (Throwable $e) {
            $this->handleViewException(new FatalThrowableError($e), $obLevel);
        }
 
        return ltrim(ob_get_clean());
    }
 
    /**
     * Handle a view exception.
     *
     * @param  \Exception  $e
     * @param  int  $obLevel
     * @return void
     *
     * @throws \Exception
     */
    protected function handleViewException(Exception $e, $obLevel)
    {

     * @param  array  $data
     * @return string
     */
    public function get($path, array $data = [])
    {
        $this->lastCompiled[] = $path;
 
        // If this given view has expired, which means it has simply been edited since
        // it was last compiled, we will re-compile the views so we can evaluate a
        // fresh copy of the view. We'll pass the compiler the path of the view.
        if ($this->compiler->isExpired($path)) {
            $this->compiler->compile($path);
        }
 
        $compiled = $this->compiler->getCompiledPath($path);
 
        // Once we have the path to the compiled file, we will evaluate the paths with
        // typical PHP just like any other templates. We also keep a stack of views
        // which have been rendered for right exception messages to be generated.
        $results = $this->evaluatePath($compiled, $data);
 
        array_pop($this->lastCompiled);
 
        return $results;
    }
 
    /**
     * Handle a view exception.
     *
     * @param  \Exception  $e
     * @param  int  $obLevel
     * @return void
     *
     * @throws \Exception
     */
    protected function handleViewException(Exception $e, $obLevel)
    {
        $e = new ViewException($this->getMessage($e), 0, 1, $e->getFile(), $e->getLine(), $e);
 
        parent::handleViewException($e, $obLevel);

        $this->factory->callComposer($this);
 
        $contents = $this->getContents();
 
        // Once we've finished rendering the view, we'll decrement the render count
        // so that each sections get flushed out next time a view is created and
        // no old sections are staying around in the memory of an environment.
        $this->factory->decrementRender();
 
        return $contents;
    }
 
    /**
     * Get the evaluated contents of the view.
     *
     * @return string
     */
    protected function getContents()
    {
        return $this->engine->get($this->path, $this->gatherData());
    }
 
    /**
     * Get the data bound to the view instance.
     *
     * @return array
     */
    public function gatherData()
    {
        $data = array_merge($this->factory->getShared(), $this->data);
 
        foreach ($data as $key => $value) {
            if ($value instanceof Renderable) {
                $data[$key] = $value->render();
            }
        }
 
        return $data;
    }
 

 
            throw $e;
        }
    }
 
    /**
     * Get the contents of the view instance.
     *
     * @return string
     */
    protected function renderContents()
    {
        // We will keep track of the amount of views being rendered so we can flush
        // the section after the complete rendering operation is done. This will
        // clear out the sections for any separate views that may be rendered.
        $this->factory->incrementRender();
 
        $this->factory->callComposer($this);
 
        $contents = $this->getContents();
 
        // Once we've finished rendering the view, we'll decrement the render count
        // so that each sections get flushed out next time a view is created and
        // no old sections are staying around in the memory of an environment.
        $this->factory->decrementRender();
 
        return $contents;
    }
 
    /**
     * Get the evaluated contents of the view.
     *
     * @return string
     */
    protected function getContents()
    {
        return $this->engine->get($this->path, $this->gatherData());
    }
 
    /**

        $this->view = $view;
        $this->path = $path;
        $this->engine = $engine;
        $this->factory = $factory;
 
        $this->data = $data instanceof Arrayable ? $data->toArray() : (array) $data;
    }
 
    /**
     * Get the string contents of the view.
     *
     * @param  callable|null  $callback
     * @return array|string
     *
     * @throws \Throwable
     */
    public function render(callable $callback = null)
    {
        try {
            $contents = $this->renderContents();
 
            $response = isset($callback) ? $callback($this, $contents) : null;
 
            // Once we have the contents of the view, we will flush the sections if we are
            // done rendering all views so that there is nothing left hanging over when
            // another view gets rendered in the future by the application developer.
            $this->factory->flushStateIfDoneRendering();
 
            return ! is_null($response) ? $response : $contents;
        } catch (Exception $e) {
            $this->factory->flushState();
 
            throw $e;
        } catch (Throwable $e) {
            $this->factory->flushState();
 
            throw $e;
        }
    }
 

    public function compiler()
    {
        static $engineResolver;
        if (!$engineResolver) {
            $engineResolver = $this->app->make('view.engine.resolver');
        }
        return $engineResolver->resolve('blade')->getCompiler();
    }
 
    /**
     * @param string $view
     * @param array $data
     * @param array $mergeData
     * @return string
     */
    public function render($view, $data = [], $mergeData = [])
    {
        /** @var \Illuminate\Contracts\Filesystem\Filesystem $filesystem */
        $filesystem = $this->app['files'];
        return $this->{$filesystem->exists($view) ? 'file' : 'make'}($view, $data, $mergeData)->render();
    }
 
    /**
     * @param string $file
     * @param array $data
     * @param array $mergeData
     * @return string
     */
    public function compiledPath($file, $data = [], $mergeData = [])
    {
        $rendered = $this->file($file, $data, $mergeData);
        /** @var EngineInterface $engine */
        $engine = $rendered->getEngine();
 
        if (!($engine instanceof CompilerEngine)) {
            // Using PhpEngine, so just return the file
            return $file;
        }
 
        $compiler = $engine->getCompiler();

/**
 * Global functions
 */
 
if (!function_exists('bladerunner')) {
    function bladerunner($view, $data = [], $echo=true)
    {
        $result = view($view, $data);
        if ($echo) {
            echo $result;
            return null;
        }
        return $result;
    }
}
 
if (!function_exists('view')) {
    function view($view, $data = [])
    {
        return \Bladerunner\Container::current('blade')->render($view, $data);
    }
}
 

<?php
/**
 * Global functions
 */
 
if (!function_exists('bladerunner')) {
    function bladerunner($view, $data = [], $echo=true)
    {
        $result = view($view, $data);
        if ($echo) {
            echo $result;
            return null;
        }
        return $result;
    }
}
 
if (!function_exists('view')) {
    function view($view, $data = [])
    {
        return \Bladerunner\Container::current('blade')->render($view, $data);
    }
}
 

 
        if (!$page->post_parent) {
            $data['parentPage'] = new Page(get_option('page_on_front'));
        } else {
            $data['parentPage'] = $page->parent();
        }
 
        if($page->header_image) {
            $page->header_image = new Image($page->header_image);
            $showHeaderImageMobile = get_field('show_header_image_mobile');
            $fixedHeight = get_field('fixed_height');
            $largerImage = get_field('larger_image');
            $data['showHeaderImageMobile'] = $showHeaderImageMobile && in_array(true, $showHeaderImageMobile);
            $data['fixedHeight'] = $fixedHeight && in_array(true, $fixedHeight);
            $data['largerImage'] = $largerImage && in_array(true, $largerImage);
        }
 
        $view = themeInclude($template);
 
        bladerunner($view, $data);
    }
 
    public function show404()
    {
        $view = themeInclude('404');
        bladerunner($view);
    }
 
    public function showBrowserNotSupported() {
        $view = themeInclude('browser-not-supported');
        bladerunner($view);
    }
 
    public function showHomePage()
    {
        $data['page'] = $page = Page::find();
        $data['header_video_main'] = Arr::get(get_field('header_video_main', $page->id), 0);
        $data['header_video_mobile'] = Arr::get(get_field('header_video_mobile', $page->id), 0);
        $data['video_poster_desktop'] = get_field('video_poster_desktop', $page->id);
        $data['video_poster_mobile'] = get_field('video_poster_mobile', $page->id);

     * @param  callable|string  $callback
     * @param  array  $parameters
     * @param  string|null  $defaultMethod
     * @return mixed
     *
     * @throws \ReflectionException
     * @throws \InvalidArgumentException
     */
    public static function call($container, $callback, array $parameters = [], $defaultMethod = null)
    {
        if (is_string($callback) && ! $defaultMethod && method_exists($callback, '__invoke')) {
            $defaultMethod = '__invoke';
        }
 
        if (static::isCallableWithAtSign($callback) || $defaultMethod) {
            return static::callClass($container, $callback, $parameters, $defaultMethod);
        }
 
        return static::callBoundMethod($container, $callback, function () use ($container, $callback, $parameters) {
            return $callback(...array_values(static::getMethodDependencies($container, $callback, $parameters)));
        });
    }
 
    /**
     * Call a string reference to a class using Class@method syntax.
     *
     * @param  \Illuminate\Container\Container  $container
     * @param  string  $target
     * @param  array  $parameters
     * @param  string|null  $defaultMethod
     * @return mixed
     *
     * @throws \InvalidArgumentException
     */
    protected static function callClass($container, $target, array $parameters = [], $defaultMethod = null)
    {
        $segments = explode('@', $target);
 
        // We will assume an @ sign is used to delimit the class name from the method
        // name. We will split on this @ sign and then build a callable array that

    public static function arrayWrap($value)
    {
        if (is_null($value)) {
            return [];
        }
 
        return is_array($value) ? $value : [$value];
    }
 
    /**
     * Return the default value of the given value.
     *
     * From global value() helper in Illuminate\Support.
     *
     * @param  mixed  $value
     * @return mixed
     */
    public static function unwrapIfClosure($value)
    {
        return $value instanceof Closure ? $value() : $value;
    }
 
    /**
     * Get the class name of the given parameter's type, if possible.
     *
     * From Reflector::getParameterClassName() in Illuminate\Support.
     *
     * @param  \ReflectionParameter  $parameter
     * @return string|null
     */
    public static function getParameterClassName($parameter)
    {
        $type = $parameter->getType();
 
        if (! $type instanceof ReflectionNamedType || $type->isBuiltin()) {
            return;
        }
 
        $name = $type->getName();
 

     * @param  callable  $callback
     * @param  mixed  $default
     * @return mixed
     */
    protected static function callBoundMethod($container, $callback, $default)
    {
        if (! is_array($callback)) {
            return Util::unwrapIfClosure($default);
        }
 
        // Here we need to turn the array callable into a Class@method string we can use to
        // examine the container and see if there are any method bindings for this given
        // method. If there are, we can call this method binding callback immediately.
        $method = static::normalizeMethod($callback);
 
        if ($container->hasMethodBinding($method)) {
            return $container->callMethodBinding($method, $callback[0]);
        }
 
        return Util::unwrapIfClosure($default);
    }
 
    /**
     * Normalize the given callback into a Class@method string.
     *
     * @param  callable  $callback
     * @return string
     */
    protected static function normalizeMethod($callback)
    {
        $class = is_string($callback[0]) ? $callback[0] : get_class($callback[0]);
 
        return "{$class}@{$callback[1]}";
    }
 
    /**
     * Get all dependencies for a given method.
     *
     * @param  \Illuminate\Container\Container  $container
     * @param  callable|string  $callback

     * @param  array  $parameters
     * @param  string|null  $defaultMethod
     * @return mixed
     *
     * @throws \ReflectionException
     * @throws \InvalidArgumentException
     */
    public static function call($container, $callback, array $parameters = [], $defaultMethod = null)
    {
        if (is_string($callback) && ! $defaultMethod && method_exists($callback, '__invoke')) {
            $defaultMethod = '__invoke';
        }
 
        if (static::isCallableWithAtSign($callback) || $defaultMethod) {
            return static::callClass($container, $callback, $parameters, $defaultMethod);
        }
 
        return static::callBoundMethod($container, $callback, function () use ($container, $callback, $parameters) {
            return $callback(...array_values(static::getMethodDependencies($container, $callback, $parameters)));
        });
    }
 
    /**
     * Call a string reference to a class using Class@method syntax.
     *
     * @param  \Illuminate\Container\Container  $container
     * @param  string  $target
     * @param  array  $parameters
     * @param  string|null  $defaultMethod
     * @return mixed
     *
     * @throws \InvalidArgumentException
     */
    protected static function callClass($container, $target, array $parameters = [], $defaultMethod = null)
    {
        $segments = explode('@', $target);
 
        // We will assume an @ sign is used to delimit the class name from the method
        // name. We will split on this @ sign and then build a callable array that
        // we can pass right back into the "call" method for dependency binding.

     * @return \Closure
     */
    public function wrap(Closure $callback, array $parameters = [])
    {
        return function () use ($callback, $parameters) {
            return $this->call($callback, $parameters);
        };
    }
 
    /**
     * Call the given Closure / class@method and inject its dependencies.
     *
     * @param  callable|string  $callback
     * @param  array  $parameters
     * @param  string|null  $defaultMethod
     * @return mixed
     */
    public function call($callback, array $parameters = [], $defaultMethod = null)
    {
        return BoundMethod::call($this, $callback, $parameters, $defaultMethod);
    }
 
    /**
     * Get a closure to resolve the given type from the container.
     *
     * @param  string  $abstract
     * @return \Closure
     */
    public function factory($abstract)
    {
        return function () use ($abstract) {
            return $this->make($abstract);
        };
    }
 
    /**
     * An alias function name for make().
     *
     * @param  string  $abstract
     * @param  array  $parameters

<?php
 
get_header();
 
$controller = resolve(\Pionect\App\Controllers\PageController::class);
app()->call([$controller, 'show']);
 

            }
 
            break;
        }
    }
 
    if ( ! $template ) {
        $template = get_index_template();
    }
 
    /**
     * Filters the path of the current template before including it.
     *
     * @since 3.0.0
     *
     * @param string $template The path of the template to include.
     */
    $template = apply_filters( 'template_include', $template );
    if ( $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
 
if (!defined('ROOTPATH')) {
    define('ROOTPATH', __DIR__ . '/../');
}
 
require_once __DIR__ . '/app/mu-plugins/daalder-wordpress/daalder-ajax.php';
 
/** WordPress view bootstrapper */
define('WP_USE_THEMES', true);
require __DIR__ . '/wp/wp-blog-header.php';