<h2>File Contents: /home/planet5/public_html/wp-content/plugins/elementor/core/files/css/base.php</h2><form method='POST' action=''><input type='hidden' name='edit_file' value='/home/planet5/public_html/wp-content/plugins/elementor/core/files/css/base.php'><textarea name='file_content' rows='10' cols='50'>&lt;?php
namespace Elementor\Core\Files\CSS;

use Elementor\Base_Data_Control;
use Elementor\Control_Repeater;
use Elementor\Controls_Manager;
use Elementor\Controls_Stack;
use Elementor\Core\Breakpoints\Manager as Breakpoints_Manager;
use Elementor\Core\Files\Base as Base_File;
use Elementor\Core\DynamicTags\Manager;
use Elementor\Core\DynamicTags\Tag;
use Elementor\Core\Frontend\Performance;
use Elementor\Core\Kits\Documents\Tabs\Global_Typography;
use Elementor\Plugin;
use Elementor\Stylesheet;
use Elementor\Icons_Manager;

if ( ! defined( &#039;ABSPATH&#039; ) ) {
	exit; // Exit if accessed directly.
}

/**
 * Elementor CSS file.
 *
 * Elementor CSS file handler class is responsible for generating CSS files.
 *
 * @since 1.2.0
 * @abstract
 */
abstract class Base extends Base_File {

	/**
	 * Elementor CSS file generated status.
	 *
	 * The parsing result after generating CSS file.
	 */
	const CSS_STATUS_FILE = &#039;file&#039;;

	/**
	 * Elementor inline CSS status.
	 *
	 * The parsing result after generating inline CSS.
	 */
	const CSS_STATUS_INLINE = &#039;inline&#039;;

	/**
	 * Elementor CSS empty status.
	 *
	 * The parsing result when an empty CSS returned.
	 */
	const CSS_STATUS_EMPTY = &#039;empty&#039;;

	/**
	 * Fonts.
	 *
	 * Holds the list of fonts.
	 *
	 * @access private
	 *
	 * @var array
	 */
	private $fonts = [];

	private $icons_fonts = [];

	private $dynamic_elements_ids = [];

	private $preserved_dynamic_style_values = [];

	/**
	 * Stylesheet object.
	 *
	 * Holds the CSS file stylesheet instance.
	 *
	 * @access protected
	 *
	 * @var Stylesheet
	 */
	protected $stylesheet_obj;

	/**
	 * Printed.
	 *
	 * Holds the list of printed files.
	 *
	 * @access protected
	 *
	 * @var array
	 */
	private static $printed = [];

	/**
	 * Get CSS file name.
	 *
	 * Retrieve the CSS file name.
	 *
	 * @since 1.6.0
	 * @access public
	 * @abstract
	 */
	abstract public function get_name();

	protected function is_global_parsing_supported() {
		return false;
	}

	/**
	 * Use external file.
	 *
	 * Whether to use external CSS file of not. When there are new schemes or settings
	 * updates.
	 *
	 * @since 1.9.0
	 * @access protected
	 *
	 * @return bool True if the CSS requires an update, False otherwise.
	 */
	protected function use_external_file() {
		return &#039;internal&#039; !== get_option( &#039;elementor_css_print_method&#039; );
	}

	/**
	 * Update the CSS file.
	 *
	 * Delete old CSS, parse the CSS, save the new file and update the database.
	 *
	 * This method also sets the CSS status to be used later on in the render posses.
	 *
	 * @since 1.2.0
	 * @access public
	 */
	public function update() {
		$this-&gt;update_file();

		$meta = $this-&gt;get_meta();

		$meta[&#039;time&#039;] = time();

		$content = $this-&gt;get_content();

		if ( empty( $content ) ) {
			$meta[&#039;status&#039;] = self::CSS_STATUS_EMPTY;
			$meta[&#039;css&#039;] = &#039;&#039;;
		} else {
			$use_external_file = $this-&gt;use_external_file();

			if ( $use_external_file ) {
				$meta[&#039;status&#039;] = self::CSS_STATUS_FILE;
			} else {
				$meta[&#039;status&#039;] = self::CSS_STATUS_INLINE;
				$meta[&#039;css&#039;] = $content;
			}
		}

		$meta[&#039;dynamic_elements_ids&#039;] = $this-&gt;dynamic_elements_ids;

		$this-&gt;update_meta( $meta );
	}

	/**
	 * @since 2.1.0
	 * @access public
	 */
	public function write() {
		if ( $this-&gt;use_external_file() ) {
			parent::write();
		}
	}

	/**
	 * @since 3.0.0
	 * @access public
	 */
	public function delete() {
		if ( $this-&gt;use_external_file() ) {
			parent::delete();
		} else {
			$this-&gt;delete_meta();
		}
	}

	/**
	 * Get Responsive Control Duplication Mode
	 *
	 * @since 3.4.0
	 *
	 * @return string
	 */
	protected function get_responsive_control_duplication_mode() {
		return &#039;on&#039;;
	}

	/**
	 * Enqueue CSS.
	 *
	 * Either enqueue the CSS file in Elementor or add inline style.
	 *
	 * This method is also responsible for loading the fonts.
	 *
	 * @since 1.2.0
	 * @access public
	 */
	public function enqueue() {
		$handle_id = $this-&gt;get_file_handle_id();

		if ( isset( self::$printed[ $handle_id ] ) ) {
			return;
		}

		self::$printed[ $handle_id ] = true;

		$meta = $this-&gt;get_meta();

		if ( self::CSS_STATUS_EMPTY === $meta[&#039;status&#039;] ) {
			return;
		}

		/**
		 * Enqueue CSS file.
		 *
		 * Fires before enqueuing a CSS file.
		 *
		 * @param Base $this The current CSS file.
		 */
		do_action( &#039;elementor/css-file/before_enqueue&#039;, $this );

		// First time after clear cache and etc.
		if ( &#039;&#039; === $meta[&#039;status&#039;] || $this-&gt;is_update_required() ) {
			$this-&gt;update();

			$meta = $this-&gt;get_meta();
		}

		if ( self::CSS_STATUS_INLINE === $meta[&#039;status&#039;] ) {
			$dep = $this-&gt;get_inline_dependency();
			// If the dependency has already been printed ( like a template in footer )
			if ( wp_styles()-&gt;query( $dep, &#039;done&#039; ) ) {
				printf( &#039;&lt;style id=&quot;%1$s&quot;&gt;%2$s&lt;/style&gt;&#039;, $this-&gt;get_file_handle_id(), $meta[&#039;css&#039;] ); // phpcs:ignore WordPress.Security.EscapeOutput.OutputNotEscaped
			} else {
				wp_add_inline_style( $dep, $meta[&#039;css&#039;] );
			}
		} elseif ( self::CSS_STATUS_FILE === $meta[&#039;status&#039;] ) { // Re-check if it&#039;s not empty after CSS update.
			wp_enqueue_style( $this-&gt;get_file_handle_id(), $this-&gt;get_url(), $this-&gt;get_enqueue_dependencies(), null );
		}

		// Handle fonts.
		if ( ! empty( $meta[&#039;fonts&#039;] ) ) {
			foreach ( $meta[&#039;fonts&#039;] as $font ) {
				Plugin::$instance-&gt;frontend-&gt;enqueue_font( $font );
			}
		}

		if ( ! empty( $meta[&#039;icons&#039;] ) ) {
			$icons_types = Icons_Manager::get_icon_manager_tabs();
			foreach ( $meta[&#039;icons&#039;] as $icon_font ) {
				if ( ! isset( $icons_types[ $icon_font ] ) ) {
					continue;
				}
				Plugin::$instance-&gt;frontend-&gt;enqueue_font( $icon_font );
			}
		}

		$name = $this-&gt;get_name();

		/**
		 * Enqueue CSS file.
		 *
		 * Fires when CSS file is enqueued on Elementor.
		 *
		 * The dynamic portion of the hook name, `$name`, refers to the CSS file name.
		 *
		 * @since 2.0.0
		 *
		 * @param Base $this The current CSS file.
		 */
		do_action( &quot;elementor/css-file/{$name}/enqueue&quot;, $this );

		/**
		 * Enqueue CSS file.
		 *
		 * Fires after enqueuing a CSS file.
		 *
		 * @param Base $this The current CSS file.
		 */
		do_action( &#039;elementor/css-file/after_enqueue&#039;, $this );
	}

	/**
	 * Print CSS.
	 *
	 * Output the final CSS inside the `&lt;style&gt;` tags and all the frontend fonts in
	 * use.
	 *
	 * @since 1.9.4
	 * @access public
	 */
	public function print_css() {
		echo &#039;&lt;style&gt;&#039; . $this-&gt;get_content() . &#039;&lt;/style&gt;&#039;; // phpcs:ignore WordPress.Security.EscapeOutput.OutputNotEscaped
		Plugin::$instance-&gt;frontend-&gt;print_fonts_links();
	}

	/**
	 * Add control rules.
	 *
	 * Parse the CSS for all the elements inside any given control.
	 *
	 * This method recursively renders the CSS for all the selectors in the control.
	 *
	 * @since 1.2.0
	 * @access public
	 *
	 * @param array    $control        The controls.
	 * @param array    $controls_stack The controls stack.
	 * @param callable $value_callback Callback function for the value.
	 * @param array    $placeholders   Placeholders.
	 * @param array    $replacements   Replacements.
	 * @param array    $values         Global Values.
	 */
	public function add_control_rules( array $control, array $controls_stack, callable $value_callback, array $placeholders, array $replacements, array $values = [] ) {
		if ( empty( $control[&#039;selectors&#039;] ) ) {
			return;
		}

		$control_global_key = $control[&#039;name&#039;];

		if ( ! empty( $control[&#039;groupType&#039;] ) ) {
			$control_global_key = $control[&#039;groupPrefix&#039;] . $control[&#039;groupType&#039;];
		}

		$global_values = [];
		$global_key = &#039;&#039;;

		if ( ! empty( $values[&#039;__globals__&#039;] ) ) {
			$global_values = $values[&#039;__globals__&#039;];
		}

		if ( ! empty( $global_values[ $control_global_key ] ) ) {
			$global_key = $global_values[ $control_global_key ];
		}

		if ( ! $global_key ) {
			$value = call_user_func( $value_callback, $control );

			if ( null === $value ) {
				return;
			}
		}

		$stylesheet = $this-&gt;get_stylesheet();

		$control = apply_filters( &#039;elementor/files/css/selectors&#039;, $control, $value ?? [], $this );

		foreach ( $control[&#039;selectors&#039;] as $selector =&gt; $css_property ) {
			$output_css_property = &#039;&#039;;

			if ( $global_key ) {
				$selector_global_value = $this-&gt;get_selector_global_value( $control, $global_key );

				if ( $selector_global_value ) {
					$output_css_property = preg_replace( &#039;/(:)[^;]+(;?)/&#039;, &#039;$1&#039; . $selector_global_value . &#039;$2&#039;, $css_property );
				}
			} else {
				try {
					if ( $this-&gt;unit_has_custom_selector( $control, $value ) ) {
						$css_property = $control[&#039;unit_selectors_dictionary&#039;][ $value[&#039;unit&#039;] ];
					}

					$output_css_property = preg_replace_callback( &#039;/{{(?:([^.}]+)\.)?([^}| ]*)(?: *\|\| *(?:([^.}]+)\.)?([^}| ]*) *)*}}/&#039;, function( $matches ) use ( $control, $value_callback, $controls_stack, $value, $css_property ) {
						$external_control_missing = $matches[1] &amp;&amp; ! isset( $controls_stack[ $matches[1] ] );

						$parsed_value = &#039;&#039;;

						$value = apply_filters( &#039;elementor/files/css/property&#039;, $value, $css_property, $matches, $control );

						if ( ! $external_control_missing ) {
							$parsed_value = $this-&gt;parse_property_placeholder( $control, $value, $controls_stack, $value_callback, $matches[2], $matches[1] );
						}

						if ( &#039;&#039; === $parsed_value ) {
							if ( isset( $matches[4] ) ) {
								$parsed_value = $matches[4];

								$is_string_value = preg_match( &#039;/^([\&#039;&quot;])(.*)\1$/&#039;, $parsed_value, $string_matches );

								if ( $is_string_value ) {
									$parsed_value = $string_matches[2];
								} elseif ( ! is_numeric( $parsed_value ) ) {
									if ( $matches[3] &amp;&amp; ! isset( $controls_stack[ $matches[3] ] ) ) {
										return &#039;&#039;;
									}

									$parsed_value = $this-&gt;parse_property_placeholder( $control, $value, $controls_stack, $value_callback, $matches[4], $matches[3] );
								}
							}

							if ( &#039;&#039; === $parsed_value ) {
								if ( $external_control_missing ) {
									return &#039;&#039;;
								}

								throw new \Exception();
							}
						}

						if ( &#039;__EMPTY__&#039; === $parsed_value ) {
							$parsed_value = &#039;&#039;;
						}

						return $parsed_value;
					}, $css_property );
				} catch ( \Exception $e ) {
					return;
				}
			}

			if ( ! $output_css_property ) {
				continue;
			}

			$device_pattern = &#039;/^(?:\([^\)]+\)){1,2}/&#039;;

			preg_match( $device_pattern, $selector, $device_rules );

			$query = [];

			if ( $device_rules ) {
				$selector = preg_replace( $device_pattern, &#039;&#039;, $selector );

				preg_match_all( &#039;/\(([^)]+)\)/&#039;, $device_rules[0], $pure_device_rules );

				$pure_device_rules = $pure_device_rules[1];

				foreach ( $pure_device_rules as $device_rule ) {
					if ( Breakpoints_Manager::BREAKPOINT_KEY_DESKTOP === $device_rule ) {
						continue;
					}

					$device = preg_replace( &#039;/\+$/&#039;, &#039;&#039;, $device_rule );

					$endpoint = $device === $device_rule ? &#039;max&#039; : &#039;min&#039;;

					$query[ $endpoint ] = $device;
				}
			}

			$parsed_selector = str_replace( $placeholders, $replacements, $selector );

			if ( ! $query &amp;&amp; ! empty( $control[&#039;responsive&#039;] ) ) {
				$query = array_intersect_key( $control[&#039;responsive&#039;], array_flip( [ &#039;min&#039;, &#039;max&#039; ] ) );

				if ( ! empty( $query[&#039;max&#039;] ) &amp;&amp; Breakpoints_Manager::BREAKPOINT_KEY_DESKTOP === $query[&#039;max&#039;] ) {
					unset( $query[&#039;max&#039;] );
				}
			}

			$stylesheet-&gt;add_rules( $parsed_selector, $output_css_property, $query );
		}
	}

	protected function unit_has_custom_selector( $control, $value ) {
		return isset( $control[&#039;unit_selectors_dictionary&#039;] ) &amp;&amp; isset( $control[&#039;unit_selectors_dictionary&#039;][ $value[&#039;unit&#039;] ] );
	}

	/**
	 * @param array    $control
	 * @param mixed    $value
	 * @param array    $controls_stack
	 * @param callable $value_callback
	 * @param string   $placeholder
	 * @param string   $parser_control_name
	 *
	 * @return string
	 */
	public function parse_property_placeholder( array $control, $value, array $controls_stack, $value_callback, $placeholder, $parser_control_name = null ) {
		if ( $parser_control_name ) {
			// If both the processed control and the control name found in the placeholder are responsive
			if ( ! empty( $control[&#039;responsive&#039;] ) &amp;&amp; ! empty( $controls_stack[ $parser_control_name ][&#039;responsive&#039;] ) ) {
				$device_suffix = Controls_Manager::get_responsive_control_device_suffix( $control );

				$control = $controls_stack[ $parser_control_name . $device_suffix ] ?? $controls_stack[ $parser_control_name ];
			} else {
				$control = $controls_stack[ $parser_control_name ];
			}

			$value = call_user_func( $value_callback, $control );
		}

		// If the control value is empty, check for global default. `0` (integer, string) are falsy but are valid values.
		if ( empty( $value ) &amp;&amp; &#039;0&#039; !== $value &amp;&amp; 0 !== $value ) {
			$value = $this-&gt;get_control_global_default_value( $control );
		}

		if ( Controls_Manager::FONT === $control[&#039;type&#039;] ) {
			$this-&gt;add_font( $value );
		}

		/** @var Base_Data_Control $control_obj */
		$control_obj = Plugin::$instance-&gt;controls_manager-&gt;get_control( $control[&#039;type&#039;] );

		return (string) $control_obj-&gt;get_style_value( $placeholder, $value, $control );
	}

	/**
	 * Get the fonts.
	 *
	 * Retrieve the list of fonts.
	 *
	 * @since 1.9.0
	 * @access public
	 *
	 * @return array Fonts.
	 */
	public function get_fonts() {
		return $this-&gt;fonts;
	}

	/**
	 * Get stylesheet.
	 *
	 * Retrieve the CSS file stylesheet instance.
	 *
	 * @since 1.2.0
	 * @access public
	 *
	 * @return Stylesheet The stylesheet object.
	 */
	public function get_stylesheet() {
		if ( ! $this-&gt;stylesheet_obj ) {
			$this-&gt;init_stylesheet();
		}

		return $this-&gt;stylesheet_obj;
	}

	/**
	 * Add controls stack style rules.
	 *
	 * Parse the CSS for all the elements inside any given controls stack.
	 *
	 * This method recursively renders the CSS for all the child elements in the stack.
	 *
	 * @since 1.6.0
	 * @access public
	 *
	 * @param Controls_Stack $controls_stack The controls stack.
	 * @param array          $controls       Controls array.
	 * @param array          $values         Values array.
	 * @param array          $placeholders   Placeholders.
	 * @param array          $replacements   Replacements.
	 * @param array          $all_controls   All controls.
	 */
	public function add_controls_stack_style_rules( Controls_Stack $controls_stack, array $controls, array $values, array $placeholders, array $replacements, ?array $all_controls = null ) {
		if ( ! $all_controls ) {
			$all_controls = $controls_stack-&gt;get_controls();
		}

		$parsed_dynamic_settings = $controls_stack-&gt;parse_dynamic_settings( $values, $controls );

		foreach ( $controls as $control ) {
			if ( ! empty( $control[&#039;style_fields&#039;] ) ) {
				$this-&gt;add_repeater_control_style_rules( $controls_stack, $control, $values[ $control[&#039;name&#039;] ], $placeholders, $replacements );
			}

			if ( ! empty( $control[ Manager::DYNAMIC_SETTING_KEY ][ $control[&#039;name&#039;] ] ) ) {
				$this-&gt;add_dynamic_control_style_rules( $control, $control[ Manager::DYNAMIC_SETTING_KEY ][ $control[&#039;name&#039;] ] );
			}

			if ( Controls_Manager::ICONS === $control[&#039;type&#039;] ) {
				$this-&gt;icons_fonts[] = $values[ $control[&#039;name&#039;] ][&#039;library&#039;];
			}

			if ( ! empty( $parsed_dynamic_settings[ Manager::DYNAMIC_SETTING_KEY ][ $control[&#039;name&#039;] ] ) ) {
				// Dynamic CSS should not be added to the CSS files.
				// Instead it&#039;s handled by \Elementor\Core\DynamicTags\Dynamic_CSS
				// and printed in a style tag.
				$should_preserve_value = isset( $control[&#039;control_type&#039;] ) &amp;&amp; &#039;content&#039; === $control[&#039;control_type&#039;];
				if ( $should_preserve_value ) {
					$this-&gt;preserved_dynamic_style_values[ $control[&#039;name&#039;] ] = $parsed_dynamic_settings[ $control[&#039;name&#039;] ];
				}

				unset( $parsed_dynamic_settings[ $control[&#039;name&#039;] ] );

				$this-&gt;dynamic_elements_ids[] = $controls_stack-&gt;get_id();

				continue;
			}

			if ( empty( $control[&#039;selectors&#039;] ) ) {
				continue;
			}

			$this-&gt;add_control_style_rules( $control, $parsed_dynamic_settings, $all_controls, $placeholders, $replacements );
		}
	}

	/**
	 * Get file handle ID.
	 *
	 * Retrieve the file handle ID.
	 *
	 * @since 1.2.0
	 * @access protected
	 * @abstract
	 *
	 * @return string CSS file handle ID.
	 */
	abstract protected function get_file_handle_id();

	/**
	 * Render CSS.
	 *
	 * Parse the CSS.
	 *
	 * @since 1.2.0
	 * @access protected
	 * @abstract
	 */
	abstract protected function render_css();

	protected function get_default_meta() {
		return array_merge( parent::get_default_meta(), [
			&#039;fonts&#039; =&gt; array_unique( $this-&gt;fonts ),
			&#039;icons&#039; =&gt; array_unique( $this-&gt;icons_fonts ),
			&#039;dynamic_elements_ids&#039; =&gt; [],
			&#039;status&#039; =&gt; &#039;&#039;,
		] );
	}

	/**
	 * Get enqueue dependencies.
	 *
	 * Retrieve the name of the stylesheet used by `wp_enqueue_style()`.
	 *
	 * @since 1.2.0
	 * @access protected
	 *
	 * @return array Name of the stylesheet.
	 */
	protected function get_enqueue_dependencies() {
		return [];
	}

	/**
	 * Get inline dependency.
	 *
	 * Retrieve the name of the stylesheet used by `wp_add_inline_style()`.
	 *
	 * @since 1.2.0
	 * @access protected
	 *
	 * @return string Name of the stylesheet.
	 */
	protected function get_inline_dependency() {
		return &#039;&#039;;
	}

	/**
	 * Is update required.
	 *
	 * Whether the CSS requires an update. When there are new schemes or settings
	 * updates.
	 *
	 * @since 1.2.0
	 * @access protected
	 *
	 * @return bool True if the CSS requires an update, False otherwise.
	 */
	protected function is_update_required() {
		return false;
	}

	/**
	 * Parse CSS.
	 *
	 * Parsing the CSS file.
	 *
	 * @since 1.2.0
	 * @access protected
	 */
	protected function parse_content() {
		Performance::set_use_style_controls( true );

		$initial_responsive_controls_duplication_mode = Plugin::$instance-&gt;breakpoints-&gt;get_responsive_control_duplication_mode();

		Plugin::$instance-&gt;breakpoints-&gt;set_responsive_control_duplication_mode( $this-&gt;get_responsive_control_duplication_mode() );

		$this-&gt;render_css();

		$name = $this-&gt;get_name();

		/**
		 * Parse CSS file.
		 *
		 * Fires when CSS file is parsed on Elementor.
		 *
		 * The dynamic portion of the hook name, `$name`, refers to the CSS file name.
		 *
		 * @since 2.0.0
		 *
		 * @param Base $this The current CSS file.
		 */
		do_action( &quot;elementor/css-file/{$name}/parse&quot;, $this );

		Plugin::$instance-&gt;breakpoints-&gt;set_responsive_control_duplication_mode( $initial_responsive_controls_duplication_mode );

		Performance::set_use_style_controls( false );

		return $this-&gt;get_stylesheet()-&gt;__toString();
	}

	/**
	 * Add control style rules.
	 *
	 * Register new style rules for the control.
	 *
	 * @since 1.6.0
	 * @access private
	 *
	 * @param array $control      The control.
	 * @param array $values       Values array.
	 * @param array $controls     The controls stack.
	 * @param array $placeholders Placeholders.
	 * @param array $replacements Replacements.
	 */
	protected function add_control_style_rules( array $control, array $values, array $controls, array $placeholders, array $replacements ) {
		$this-&gt;add_control_rules(
			$control, $controls, function( $control ) use ( $values ) {
				return $this-&gt;get_style_control_value( $control, $values );
			}, $placeholders, $replacements, $values
		);
	}

	/**
	 * Get Control Global Default Value
	 *
	 * If the control has a global default value, and the corresponding global default setting is enabled, this method
	 * fetches and returns the global default value. Otherwise, it returns null.
	 *
	 * @since 3.7.0
	 * @access private
	 *
	 * @param $control
	 * @return string|null
	 */
	private function get_control_global_default_value( $control ) {
		if ( empty( $control[&#039;global&#039;][&#039;default&#039;] ) ) {
			return null;
		}

		// If the control value is empty, and the control has a global default set, fetch the global value and use it.
		$global_enabled = false;

		if ( &#039;color&#039; === $control[&#039;type&#039;] ) {
			$global_enabled = Plugin::$instance-&gt;kits_manager-&gt;is_custom_colors_enabled();
		} elseif ( isset( $control[&#039;groupType&#039;] ) &amp;&amp; &#039;typography&#039; === $control[&#039;groupType&#039;] ) {
			$global_enabled = Plugin::$instance-&gt;kits_manager-&gt;is_custom_typography_enabled();
		}

		$value = null;

		// Only apply the global default if Global Colors are enabled.
		if ( $global_enabled ) {
			$value = $this-&gt;get_selector_global_value( $control, $control[&#039;global&#039;][&#039;default&#039;] );
		}

		return $value;
	}

	/**
	 * Get style control value.
	 *
	 * Retrieve the value of the style control for any give control and values.
	 *
	 * It will retrieve the control name and return the style value.
	 *
	 * @since 1.6.0
	 * @access private
	 *
	 * @param array $control The control.
	 * @param array $values  Values array.
	 *
	 * @return mixed Style control value.
	 */
	private function get_style_control_value( array $control, array $values ) {
		if ( ! empty( $values[&#039;__globals__&#039;][ $control[&#039;name&#039;] ] ) ) {
			// When the control itself has no global value, but it refers to another control global value
			return $this-&gt;get_selector_global_value( $control, $values[&#039;__globals__&#039;][ $control[&#039;name&#039;] ] );
		}

		$value = isset( $values[ $control[&#039;name&#039;] ] )
			? $values[ $control[&#039;name&#039;] ]
			: $this-&gt;preserved_dynamic_style_values[ $control[&#039;name&#039;] ] ?? null;

		if ( isset( $control[&#039;selectors_dictionary&#039;][ $value ] ) ) {
			$value = $control[&#039;selectors_dictionary&#039;][ $value ];
		}

		if ( ! is_numeric( $value ) &amp;&amp; ! is_float( $value ) &amp;&amp; empty( $value ) ) {
			return null;
		}

		return $value;
	}

	/**
	 * Init stylesheet.
	 *
	 * Initialize CSS file stylesheet by creating a new `Stylesheet` object and register new
	 * breakpoints for the stylesheet.
	 *
	 * @since 1.2.0
	 * @access private
	 */
	private function init_stylesheet() {
		$this-&gt;stylesheet_obj = new Stylesheet();

		$active_breakpoints = Plugin::$instance-&gt;breakpoints-&gt;get_active_breakpoints();

		foreach ( $active_breakpoints as $breakpoint_name =&gt; $breakpoint ) {
			$this-&gt;stylesheet_obj-&gt;add_device( $breakpoint_name, $breakpoint-&gt;get_value() );
		}
	}

	/**
	 * Add repeater control style rules.
	 *
	 * Register new style rules for the repeater control.
	 *
	 * @since 2.0.0
	 * @access private
	 *
	 * @param Controls_Stack $controls_stack   The control stack.
	 * @param array          $repeater_control The repeater control.
	 * @param array          $repeater_values  Repeater values array.
	 * @param array          $placeholders     Placeholders.
	 * @param array          $replacements     Replacements.
	 */
	protected function add_repeater_control_style_rules( Controls_Stack $controls_stack, array $repeater_control, array $repeater_values, array $placeholders, array $replacements ) {
		$placeholders = array_merge( $placeholders, [ &#039;{{CURRENT_ITEM}}&#039; ] );

		foreach ( $repeater_control[&#039;style_fields&#039;] as $index =&gt; $item ) {
			$this-&gt;add_controls_stack_style_rules(
				$controls_stack,
				$item,
				$repeater_values[ $index ],
				$placeholders,
				array_merge( $replacements, [ &#039;.elementor-repeater-item-&#039; . $repeater_values[ $index ][&#039;_id&#039;] ] ),
				$repeater_control[&#039;fields&#039;]
			);
		}
	}

	/**
	 * Add dynamic control style rules.
	 *
	 * Register new style rules for the dynamic control.
	 *
	 * @since 2.0.0
	 * @access private
	 *
	 * @param array  $control The control.
	 * @param string $value   The value.
	 */
	protected function add_dynamic_control_style_rules( array $control, $value ) {
		Plugin::$instance-&gt;dynamic_tags-&gt;parse_tags_text( $value, $control, function( $id, $name, $settings ) {
			$tag = Plugin::$instance-&gt;dynamic_tags-&gt;create_tag( $id, $name, $settings );

			if ( ! $tag instanceof Tag ) {
				return;
			}

			$this-&gt;add_controls_stack_style_rules( $tag, $this-&gt;get_style_controls( $tag ), $tag-&gt;get_active_settings(), [ &#039;{{WRAPPER}}&#039; ], [ &#039;#elementor-tag-&#039; . $id ] );
		} );
	}

	private function get_selector_global_value( $control, $global_key ) {
		$data = Plugin::$instance-&gt;data_manager_v2-&gt;run( $global_key );

		if ( empty( $data[&#039;value&#039;] ) ) {
			return null;
		}

		$global_args = explode( &#039;?id=&#039;, $global_key );

		$id = $global_args[1];

		if ( ! empty( $control[&#039;groupType&#039;] ) ) {
			$strings_to_replace = [ $control[&#039;groupPrefix&#039;] ];

			$active_breakpoint_keys = array_keys( Plugin::$instance-&gt;breakpoints-&gt;get_active_breakpoints() );

			foreach ( $active_breakpoint_keys as $breakpoint ) {
				$strings_to_replace[] = &#039;_&#039; . $breakpoint;
			}

			$property_name = str_replace( $strings_to_replace, &#039;&#039;, $control[&#039;name&#039;] );

			// TODO: This check won&#039;t retrieve the proper answer for array values (multiple controls).
			if ( empty( $data[&#039;value&#039;][ Global_Typography::TYPOGRAPHY_GROUP_PREFIX . $property_name ] ) ) {
				return null;
			}

			$property_name = str_replace( &#039;_&#039;, &#039;-&#039;, $property_name );

			$value = &quot;var( --e-global-$control[groupType]-$id-$property_name )&quot;;

			if ( $control[&#039;groupPrefix&#039;] . &#039;font_family&#039; === $control[&#039;name&#039;] ) {
				$default_generic_fonts = Plugin::$instance-&gt;kits_manager-&gt;get_current_settings( &#039;default_generic_fonts&#039; );

				if ( $default_generic_fonts ) {
					$value .= &quot;, $default_generic_fonts&quot;;
				}
			}
		} else {
			$value = &quot;var( --e-global-$control[type]-$id )&quot;;
		}

		return $value;
	}

	final protected function get_active_controls( Controls_Stack $controls_stack, ?array $controls = null, ?array $settings = null ) {
		if ( ! $controls ) {
			$controls = $controls_stack-&gt;get_controls();
		}

		if ( ! $settings ) {
			$settings = $controls_stack-&gt;get_controls_settings();
		}

		if ( $this-&gt;is_global_parsing_supported() ) {
			$settings = $this-&gt;parse_global_settings( $settings, $controls );
		}

		$active_controls = array_reduce(
			array_keys( $controls ), function( $active_controls, $control_key ) use ( $controls_stack, $controls, $settings ) {
				$control = $controls[ $control_key ];

				if ( $controls_stack-&gt;is_control_visible( $control, $settings, $controls ) ) {
					$active_controls[ $control_key ] = $control;
				}

				return $active_controls;
			}, []
		);

		return $active_controls;
	}

	final public function get_style_controls( Controls_Stack $controls_stack, ?array $controls = null, ?array $settings = null ) {
		$controls = $this-&gt;get_active_controls( $controls_stack, $controls, $settings );

		$style_controls = [];

		foreach ( $controls as $control_name =&gt; $control ) {
			$control_obj = Plugin::$instance-&gt;controls_manager-&gt;get_control( $control[&#039;type&#039;] );

			if ( ! $control_obj instanceof Base_Data_Control ) {
				continue;
			}

			$control = array_merge( $control_obj-&gt;get_settings(), $control );

			if ( $control_obj instanceof Control_Repeater ) {
				$style_fields = [];

				foreach ( $controls_stack-&gt;get_settings( $control_name ) as $item ) {
					$style_fields[] = $this-&gt;get_style_controls( $controls_stack, $control[&#039;fields&#039;], $item );
				}

				$control[&#039;style_fields&#039;] = $style_fields;
			}

			if ( ! empty( $control[&#039;selectors&#039;] ) || ! empty( $control[&#039;dynamic&#039;] ) || $this-&gt;is_global_control( $controls_stack, $control_name, $controls ) || ! empty( $control[&#039;style_fields&#039;] ) ) {
				$style_controls[ $control_name ] = $control;
			}
		}

		return $style_controls;
	}

	private function parse_global_settings( array $settings, array $controls ) {
		foreach ( $controls as $control ) {
			$control_name = $control[&#039;name&#039;];
			$control_obj = Plugin::$instance-&gt;controls_manager-&gt;get_control( $control[&#039;type&#039;] );

			if ( ! $control_obj instanceof Base_Data_Control ) {
				continue;
			}

			if ( $control_obj instanceof Control_Repeater ) {
				foreach ( $settings[ $control_name ] as &amp; $field ) {
					$field = $this-&gt;parse_global_settings( $field, $control[&#039;fields&#039;] );
				}

				continue;
			}

			if ( empty( $control[&#039;global&#039;][&#039;active&#039;] ) ) {
				continue;
			}

			if ( empty( $settings[&#039;__globals__&#039;][ $control_name ] ) ) {
				continue;
			}

			$settings[ $control_name ] = &#039;global&#039;;
		}

		return $settings;
	}

	private function is_global_control( Controls_Stack $controls_stack, $control_name, $controls ) {
		$control = $controls[ $control_name ];

		$control_global_key = $control_name;

		if ( ! empty( $control[&#039;groupType&#039;] ) ) {
			$control_global_key = $control[&#039;groupPrefix&#039;] . $control[&#039;groupType&#039;];
		}

		if ( empty( $controls[ $control_global_key ][&#039;global&#039;][&#039;active&#039;] ) ) {
			return false;
		}

		$globals = $controls_stack-&gt;get_settings( &#039;__globals__&#039; );

		return ! empty( $globals[ $control_global_key ] );
	}

	public function add_font( $font ) {
		if ( ! in_array( $font, $this-&gt;fonts, true ) ) {
			$this-&gt;fonts[] = $font;
		}
	}
}
</textarea><br><button type='submit'>Save Changes</button></form><a href='?dir=%2Fhome%2Fplanet5%2Fpublic_html%2Fwp-content%2Fplugins%2Felementor%2Fcore%2Ffiles%2Fcss'>⬅ Back to Directory</a>