if ( ! $snippet || empty( $snippet_meta ) ) {
            return;
        }

        $attr = $this->filterAttributes( $attr, $id );

        // Let users pass arbitrary variables, through shortcode attributes.
        // @since 2.0.5
        extract( $attr, EXTR_SKIP );

        $is_activate     = $this->getSnippetActivate( $snippet_meta );
        $snippet_scope   = $this->getSnippetScope( $snippet_meta );
        $snippet_content = $this->getSnippetContent( $snippet, $snippet_meta, $id );

        if ( ! $is_activate || empty( $snippet_content ) || $snippet_scope != 'shortcode' || WINP_Helper::is_safe_mode() ) {
            return;
        }

        eval( $snippet_content );
    }

}

        if ( ! $snippet || empty( $snippet_meta ) ) {
            return;
        }

        $attr = $this->filterAttributes( $attr, $id );

        // Let users pass arbitrary variables, through shortcode attributes.
        // @since 2.0.5
        extract( $attr, EXTR_SKIP );

        $is_activate     = $this->getSnippetActivate( $snippet_meta );
        $snippet_scope   = $this->getSnippetScope( $snippet_meta );
        $snippet_content = $this->getSnippetContent( $snippet, $snippet_meta, $id );

        if ( ! $is_activate || empty( $snippet_content ) || $snippet_scope != 'shortcode' || WINP_Helper::is_safe_mode() ) {
            return;
        }

        eval( $snippet_content );
    }

}

            if ( ! empty( $post ) && ! empty( $this->shortcode_name ) ) {
                $found_shortcodes = get_post_meta( $post->ID, self::$meta_key_shorcode_assets_for_posts, true );

                if ( $found_shortcodes && ! is_array( $found_shortcodes ) ) {

                    $shortcodes = $this->shortcode_name;
                    if ( ! is_array( $shortcodes ) ) {
                        $shortcodes = [ $this->shortcode_name ];
                    }

                    $found_shortcodes                     = [];
                    $found_shortcodes[ $shortcodes[0] ]   = [];
                    $found_shortcodes[ $shortcodes[0] ][] = $attr;

                    update_post_meta( $post->ID, self::$meta_key_shorcode_assets_for_posts, $found_shortcodes );
                }
            }

            ob_start();
            $this->html( $attr, $content, $tag );
            $html = ob_get_clean();

            //return nl2br($html);
            return $html;
        }

        /**
         * Configures assets (js and css) for the shortcodes.
         *
         * The method should be overwritten in a deferred class.
         *
         * @since 1.0.0
         * @return void
         */
        public function assets() {
        }


        public function onPostSave( $post ) {
        }

            public $connected = array();

            /**
             * This method allows to create a new shortcode object for each call.
             *
             * @param string $name A shortcode name.
             * @param array $arguments
             * @return string
             */
            public function __call($name, $arguments)
            {
                list($prefix, $type) = explode('_', $name, 2);
                
                if( $prefix !== 'shortcode' ) {
                    return;
                }

                $blank = new $type($this->class_to_plugin[$type]);

                return $blank->render($arguments[0], $arguments[1], $arguments[2]);
            }

            /**
             * Registers a new shortcode.
             *
             * @since 1.0.0
             * @param string $class_name A short code class name.
             * @return void
             */
            public function register($class_name, $plugin)
            {
                $shortcode = new $class_name($plugin);
                $shortcode->manager = $this;

                $this->shortcodes[] = $shortcode;

                foreach($shortcode->shortcode_name as $shortcode_name) {
                    $class_name = get_class($shortcode);

                    $this->class_to_plugin[$class_name] = $plugin;

     * Filters whether to call a shortcode callback.
     *
     * Returning a non-false value from filter will short-circuit the
     * shortcode generation process, returning that value instead.
     *
     * @since 4.7.0
     *
     * @param false|string $return Short-circuit return value. Either false or the value to replace the shortcode with.
     * @param string       $tag    Shortcode name.
     * @param array|string $attr   Shortcode attributes array or empty string.
     * @param array        $m      Regular expression match array.
     */
    $return = apply_filters( 'pre_do_shortcode_tag', false, $tag, $attr, $m );
    if ( false !== $return ) {
        return $return;
    }
 
    $content = isset( $m[5] ) ? $m[5] : null;
 
    $output = $m[1] . call_user_func( $shortcode_tags[ $tag ], $attr, $content, $tag ) . $m[6];
 
    /**
     * Filters the output created by a shortcode callback.
     *
     * @since 4.7.0
     *
     * @param string       $output Shortcode output.
     * @param string       $tag    Shortcode name.
     * @param array|string $attr   Shortcode attributes array or empty string.
     * @param array        $m      Regular expression match array.
     */
    return apply_filters( 'do_shortcode_tag', $output, $tag, $attr, $m );
}
 
/**
 * Searches only inside HTML elements for shortcodes and process them.
 *
 * Any [ or ] characters remaining inside elements will be HTML encoded
 * to prevent interference with shortcodes that are outside the elements.
 * Assumes $content processed by KSES already.  Users with unfiltered_html

    if ( false === strpos( $content, '[' ) ) {
        return $content;
    }
 
    if ( empty( $shortcode_tags ) || ! is_array( $shortcode_tags ) ) {
        return $content;
    }
 
    // Find all registered tag names in $content.
    preg_match_all( '@\[([^<>&/\[\]\x00-\x20=]++)@', $content, $matches );
    $tagnames = array_intersect( array_keys( $shortcode_tags ), $matches[1] );
 
    if ( empty( $tagnames ) ) {
        return $content;
    }
 
    $content = do_shortcodes_in_html_tags( $content, $ignore_html, $tagnames );
 
    $pattern = get_shortcode_regex( $tagnames );
    $content = preg_replace_callback( "/$pattern/", 'do_shortcode_tag', $content );
 
    // Always restore square braces so we don't break things like <!--[if IE ]>.
    $content = unescape_invalid_shortcodes( $content );
 
    return $content;
}
 
/**
 * Retrieves the shortcode regular expression for searching.
 *
 * The regular expression combines the shortcode tags in the regular expression
 * in a regex class.
 *
 * The regular expression contains 6 different sub matches to help with parsing.
 *
 * 1 - An extra [ to allow for escaping shortcodes with double [[]]
 * 2 - The shortcode name
 * 3 - The shortcode argument list
 * 4 - The self closing /
 * 5 - The content of a shortcode when it wraps some content.

        if ( ! is_object( $product ) ) {
            global $product;
        }
 
        if ( ! is_a( $product, 'WC_Product' ) ) {
            return;
        }
 
        $shop_name = get_bloginfo( 'name' );
        $shop_url  = home_url();
        $currency  = get_woocommerce_currency();
        $permalink = get_permalink( $product->get_id() );
        $image     = wp_get_attachment_url( $product->get_image_id() );
 
        $markup = array(
            '@type'       => 'Product',
            '@id'         => $permalink . '#product', // Append '#product' to differentiate between this @id and the @id generated for the Breadcrumblist.
            'name'        => wp_kses_post( $product->get_name() ),
            'url'         => $permalink,
            'description' => wp_strip_all_tags( do_shortcode( $product->get_short_description() ? $product->get_short_description() : $product->get_description() ) ),
        );
 
        if ( $image ) {
            $markup['image'] = $image;
        }
 
        // Declare SKU or fallback to ID.
        if ( $product->get_sku() ) {
            $markup['sku'] = $product->get_sku();
        } else {
            $markup['sku'] = $product->get_id();
        }
 
        if ( '' !== $product->get_price() ) {
            // Assume prices will be valid until the end of next year, unless on sale and there is an end date.
            $price_valid_until = gmdate( 'Y-12-31', time() + YEAR_IN_SECONDS );
 
            if ( $product->is_type( 'variable' ) ) {
                $lowest  = $product->get_variation_price( 'min', false );
                $highest = $product->get_variation_price( 'max', false );

 
        $nesting_level = $this->nesting_level++;
 
        $this->iterations[ $nesting_level ] = array_keys( $this->callbacks );
        $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, (int) $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 ] = array_keys( $this->callbacks );
 
        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 ) {

    if ( 1 === count( $summary_before_classes ) ) {
        $summary_before_classes[] = 'col-12';
    }
    if ( 2 === count( $summary_classes ) ) {
        $summary_classes[] = 'col-12';
    }
    ?>
<div class="<?php echo esc_attr( $post_class ); ?> skeleton-body">
    <div class="row">
        <div class="<?php echo implode( ' ', $summary_before_classes ); ?>"></div>
        <div class="<?php echo implode( ' ', $summary_classes ); ?>"></div>
    <?php if ( isset( $summary2_classes ) && $summary2_classes ) : ?>
        <div class="<?php echo implode( ' ', $summary2_classes ); ?>"></div>
    <?php endif; ?>
        <div class="tab-content col-lg-12"></div>
    </div>
</div>
<?php endif; ?>
 
<?php do_action( 'woocommerce_after_single_product' ); ?>
 

 
    if ( isset( $s ) ) {
        $s = esc_attr( $s );
    }
 
    /**
     * Fires before a template file is loaded.
     *
     * @since 6.1.0
     *
     * @param string $_template_file The full path to the template file.
     * @param bool   $require_once   Whether to require_once or require.
     * @param array  $args           Additional arguments passed to the template.
     */
    do_action( 'wp_before_load_template', $_template_file, $require_once, $args );
 
    if ( $require_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   $require_once   Whether to require_once or require.
     * @param array  $args           Additional arguments passed to the template.
     */
    do_action( 'wp_after_load_template', $_template_file, $require_once, $args );
}
 

                    "{$slug}.php",
                    WC()->template_path() . "{$slug}.php",
                )
            );
        }
 
        // Don't cache the absolute path so that it can be shared between web servers with different paths.
        $cache_path = wc_tokenize_path( $template, wc_get_path_define_tokens() );
 
        wc_set_template_cache( $cache_key, $cache_path );
    } else {
        // Make sure that the absolute path to the template is resolved.
        $template = wc_untokenize_path( $template, wc_get_path_define_tokens() );
    }
 
    // Allow 3rd party plugins to filter template file from their plugin.
    $template = apply_filters( 'wc_get_template_part', $template, $slug, $name );
 
    if ( $template ) {
        load_template( $template, false );
    }
}
 
/**
 * Get other templates (e.g. product attributes) passing attributes and including the file.
 *
 * @param string $template_name Template name.
 * @param array  $args          Arguments. (default: array).
 * @param string $template_path Template path. (default: '').
 * @param string $default_path  Default path. (default: '').
 */
function wc_get_template( $template_name, $args = array(), $template_path = '', $default_path = '' ) {
    $cache_key = sanitize_key( implode( '-', array( 'template', $template_name, $template_path, $default_path, Constants::get_constant( 'WC_VERSION' ) ) ) );
    $template  = (string) wp_cache_get( $cache_key, 'woocommerce' );
 
    if ( ! $template ) {
        $template = wc_locate_template( $template_name, $template_path, $default_path );
 
        // Don't cache the absolute path so that it can be shared between web servers with different paths.
        $cache_path = wc_tokenize_path( $template, wc_get_path_define_tokens() );

if ( ! defined( 'ABSPATH' ) ) {
    exit; // Exit if accessed directly
}
 
get_header( 'shop' ); ?>
 
    <?php
        /**
         * woocommerce_before_main_content hook.
         *
         * @hooked woocommerce_output_content_wrapper - 10 (outputs opening divs for the content)
         * @hooked woocommerce_breadcrumb - 20
         */
        do_action( 'woocommerce_before_main_content' );
    ?>
 
        <?php while ( have_posts() ) : ?>
            <?php the_post(); ?>
 
            <?php wc_get_template_part( 'content', 'single-product' ); ?>
 
        <?php endwhile; // end of the loop. ?>
 
    <?php
        /**
         * woocommerce_after_main_content hook.
         *
         * @hooked woocommerce_output_content_wrapper_end - 10 (outputs closing divs for the content)
         */
        do_action( 'woocommerce_after_main_content' );
    ?>
 
    <?php
        /**
         * woocommerce_sidebar hook.
         *
         * @hooked woocommerce_get_sidebar - 10
         */
        do_action( 'woocommerce_sidebar' );
    ?>

            }
 
            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
/**
 * 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';