<h2>File Contents: /home/planet5/www/wp-content/themes/Divi/includes/builder/module/helpers/copy_of_Background.php</h2><form method='POST' action=''><input type='hidden' name='edit_file' value='/home/planet5/www/wp-content/themes/Divi/includes/builder/module/helpers/copy_of_Background.php'><textarea name='file_content' rows='10' cols='50'>&lt;?php
/**
 * Background helper Class.
 *
 * @package Divi
 * @subpackage Builder
 */

if ( ! defined( &#039;ABSPATH&#039; ) ) {
	die( &#039;Direct access forbidden.&#039; );
}


/**
 * Background helper methods.
 *
 * Intended for module that needs to extend module background mechanism with few modification
 * (eg. post slider which needs to apply module background on individual slide that has featured
 * image).
 *
 * @since 4.3.3
 * @since 4.6.0 Add sticky style support
 * @since 4.15.0 Add pattern/mask style support.
 *
 * Class ET_Builder_Module_Helper_Background
 */
class ET_Builder_Module_Helper_Background {
	/**
	 * Returns instance of the class.
	 *
	 * @return ET_Builder_Module_Helper_Background
	 */
	public static function instance() {
		static $instance;

		return $instance ? $instance : $instance = new self();
	}

	/**
	 * Get prop name alias. Some background settings (eg. button&#039;s gradient background enable) might
	 * use slightly different prop name to store background config;
	 *
	 * @since 4.6.0
	 *
	 * @param array  $aliases   Aliases.
	 * @param string $prop_name Prop name.
	 *
	 * @return string
	 */
	public function get_prop_name_alias( $aliases = array(), $prop_name = &#039;&#039; ) {
		// If no aliases given, simply return the prop name because it has no alias.
		if ( empty( $aliases ) ) {
			return $prop_name;
		}

		return isset( $aliases[ $prop_name ] ) ? $aliases[ $prop_name ] : $prop_name;
	}

	/**
	 * Get gradient properties for hover mode
	 *
	 * @since 4.3.3
	 * @since 4.6.0 add capability to look for sticky style&#039;s gradient
	 * @since 4.16.0   Uses the `_stops` field introduced in the Gradient Builder update.
	 *
	 * @param string $mode                        Mode name.
	 * @param array  $props                       Module&#039;s props.
	 * @param string $base_prop_name              Background base prop name.
	 * @param array  $gradient_properties_desktop {
	 *     @type string $mode
	 *     @type string $stops
	 *     @type string $type
	 *     @type string $direction
	 *     @type string $radial_direction
	 *     @type string $color_start
	 *     @type string $color_end
	 *     @type string $start_position
	 *     @type string $end_position
	 * }
	 *
	 * @return array|false
	 */
	public function get_gradient_mode_properties( $mode, $props, $base_prop_name, $gradient_properties_desktop = array() ) {
		$helper = et_builder_get_helper( $mode );

		if ( ! $mode ) {
			return false;
		}

		// Desktop value as default.
		$gradient_repeat_desktop           = et_pb_responsive_options()-&gt;get_any_value( $props, &quot;{$base_prop_name}_color_repeat_image&quot;, &#039;&#039;, true );
		$gradient_type_desktop             = et_()-&gt;array_get( $gradient_properties_desktop, &#039;type&#039;, &#039;&#039; );
		$gradient_direction_desktop        = et_()-&gt;array_get( $gradient_properties_desktop, &#039;direction&#039;, &#039;&#039; );
		$gradient_radial_direction_desktop = et_()-&gt;array_get( $gradient_properties_desktop, &#039;radial_direction&#039;, &#039;&#039; );
		$gradient_stops_desktop            = et_()-&gt;array_get( $gradient_properties_desktop, &#039;stops&#039;, &#039;&#039; );
		$gradient_unit_desktop             = et_()-&gt;array_get( $gradient_properties_desktop, &#039;unit&#039;, &#039;&#039; );
		$gradient_overlays_image_desktop   = et_pb_responsive_options()-&gt;get_any_value( $props, &quot;{$base_prop_name}_color_gradient_overlays_image&quot;, &#039;&#039;, true );

		$gradient_color_start_desktop    = et_()-&gt;array_get( $gradient_properties_desktop, &#039;color_start&#039;, &#039;&#039; );
		$gradient_color_end_desktop      = et_()-&gt;array_get( $gradient_properties_desktop, &#039;color_end&#039;, &#039;&#039; );
		$gradient_start_position_desktop = et_()-&gt;array_get( $gradient_properties_desktop, &#039;start_position&#039;, &#039;&#039; );
		$gradient_end_position_desktop   = et_()-&gt;array_get( $gradient_properties_desktop, &#039;end_position&#039;, &#039;&#039; );

		// Mode value.
		$gradient_repeat_mode           = $helper-&gt;get_raw_value( &quot;{$base_prop_name}_color_repeat_image&quot;, $props, $gradient_repeat_desktop );
		$gradient_type_mode             = $helper-&gt;get_raw_value( &quot;{$base_prop_name}_color_gradient_type&quot;, $props, $gradient_type_desktop );
		$gradient_direction_mode        = $helper-&gt;get_raw_value( &quot;{$base_prop_name}_color_gradient_direction&quot;, $props, $gradient_direction_desktop );
		$gradient_direction_radial_mode = $helper-&gt;get_raw_value( &quot;{$base_prop_name}_color_gradient_direction_radial&quot;, $props, $gradient_radial_direction_desktop );
		$gradient_stops_mode            = $helper-&gt;get_raw_value( &quot;{$base_prop_name}_color_gradient_stops&quot;, $props, $gradient_stops_desktop );
		$gradient_unit_mode             = $helper-&gt;get_raw_value( &quot;{$base_prop_name}_color_gradient_unit&quot;, $props, $gradient_unit_desktop );
		$gradient_overlays_image_mode   = $helper-&gt;get_raw_value( &quot;{$base_prop_name}_color_gradient_overlays_image&quot;, $props, $gradient_overlays_image_desktop );

		$gradient_start_mode          = $helper-&gt;get_raw_value( &quot;{$base_prop_name}_color_gradient_start&quot;, $props, $gradient_color_start_desktop );
		$gradient_end_mode            = $helper-&gt;get_raw_value( &quot;{$base_prop_name}_color_gradient_end&quot;, $props, $gradient_color_end_desktop );
		$gradient_start_position_mode = $helper-&gt;get_raw_value( &quot;{$base_prop_name}_color_gradient_start_position&quot;, $props, $gradient_start_position_desktop );
		$gradient_end_position_mode   = $helper-&gt;get_raw_value( &quot;{$base_prop_name}_color_gradient_end_position&quot;, $props, $gradient_end_position_desktop );

		$color_start_value = &#039;&#039; !== $gradient_start_mode ? $gradient_start_mode : $gradient_color_start_desktop;
		$color_end_value   = &#039;&#039; !== $gradient_end_mode ? $gradient_end_mode : $gradient_color_end_desktop;

		return array(
			&#039;repeat&#039;           =&gt; &#039;&#039; !== $gradient_repeat_mode ? $gradient_repeat_mode : $gradient_repeat_desktop,
			&#039;type&#039;             =&gt; &#039;&#039; !== $gradient_type_mode ? $gradient_type_mode : $gradient_type_desktop,
			&#039;direction&#039;        =&gt; &#039;&#039; !== $gradient_direction_mode ? $gradient_direction_mode : $gradient_direction_desktop,
			&#039;radial_direction&#039; =&gt; &#039;&#039; !== $gradient_direction_radial_mode ? $gradient_direction_radial_mode : $gradient_radial_direction_desktop,
			&#039;stops&#039;            =&gt; &#039;&#039; !== $gradient_stops_mode ? $gradient_stops_mode : $gradient_stops_desktop,
			&#039;color_start&#039;      =&gt; &#039;&#039; !== $gradient_start_mode ? $gradient_start_mode : $gradient_color_start_desktop,
			&#039;color_end&#039;        =&gt; &#039;&#039; !== $gradient_end_mode ? $gradient_end_mode : $gradient_color_end_desktop,
			&#039;start_position&#039;   =&gt; &#039;&#039; !== $gradient_start_position_mode ? $gradient_start_position_mode : $gradient_start_position_desktop,
			&#039;end_position&#039;     =&gt; &#039;&#039; !== $gradient_end_position_mode ? $gradient_end_position_mode : $gradient_end_position_desktop,
			&#039;unit&#039;             =&gt; &#039;&#039; !== $gradient_unit_mode ? $gradient_unit_mode : $gradient_stops_desktop,
		);
	}

	/**
	 * Get gradient properties based on given props
	 *
	 * @since 4.3.3
	 * @since 4.16.0   Uses the `_stops` field introduced in the Gradient Builder update.
	 *
	 * @param array  $props          Module&#039;s props.
	 * @param string $base_prop_name Background base prop name.
	 * @param string $suffix         Background base prop name&#039;s suffix.
	 *
	 * @return array
	 */
	public function get_gradient_properties( $props, $base_prop_name, $suffix ) {
		return array(
			&#039;repeat&#039;           =&gt; et_pb_responsive_options()-&gt;get_any_value( $props, &quot;{$base_prop_name}_color_gradient_repeat{$suffix}&quot;, &#039;&#039;, true ),
			&#039;type&#039;             =&gt; et_pb_responsive_options()-&gt;get_any_value( $props, &quot;{$base_prop_name}_color_gradient_type{$suffix}&quot;, &#039;&#039;, true ),
			&#039;direction&#039;        =&gt; et_pb_responsive_options()-&gt;get_any_value( $props, &quot;{$base_prop_name}_color_gradient_direction{$suffix}&quot;, &#039;&#039;, true ),
			&#039;radial_direction&#039; =&gt; et_pb_responsive_options()-&gt;get_any_value( $props, &quot;{$base_prop_name}_color_gradient_direction_radial{$suffix}&quot;, &#039;&#039;, true ),
			&#039;stops&#039;            =&gt; et_pb_responsive_options()-&gt;get_any_value( $props, &quot;{$base_prop_name}_color_gradient_stops{$suffix}&quot;, &#039;&#039;, true ),
			&#039;unit&#039;             =&gt; et_pb_responsive_options()-&gt;get_any_value( $props, &quot;{$base_prop_name}_color_gradient_unit{$suffix}&quot;, &#039;&#039;, true ),
			&#039;color_start&#039;      =&gt; et_pb_responsive_options()-&gt;get_any_value( $props, &quot;{$base_prop_name}_color_gradient_start{$suffix}&quot;, &#039;&#039;, true ),
			&#039;color_end&#039;        =&gt; et_pb_responsive_options()-&gt;get_any_value( $props, &quot;{$base_prop_name}_color_gradient_end{$suffix}&quot;, &#039;&#039;, true ),
			&#039;start_position&#039;   =&gt; et_pb_responsive_options()-&gt;get_any_value( $props, &quot;{$base_prop_name}_color_gradient_start_position{$suffix}&quot;, &#039;&#039;, true ),
			&#039;end_position&#039;     =&gt; et_pb_responsive_options()-&gt;get_any_value( $props, &quot;{$base_prop_name}_color_gradient_end_position{$suffix}&quot;, &#039;&#039;, true ),
		);
	}

	/**
	 * Get background gradient style based on properties given
	 *
	 * @since 4.3.3
	 * @since 4.16.0   Uses the `_stops` field introduced in the Gradient Builder update.
	 *
	 * @param array $args {
	 *     @type string $repeat           Whether the gradient stops repeat.
	 *     @type string $type             Linear or radial gradient.
	 *     @type string $direction        The gradient line&#039;s angle of direction.
	 *     @type string $radial_direction The position of the gradient.
	 *     @type string $stops            Brace-delimited list of color stops.
	 *     @type string $color_start      Deprecated.
	 *     @type string $color_end        Deprecated.
	 *     @type string $start_position   Deprecated.
	 *     @type string $end_position     Deprecated.
	 * }
	 *
	 * @return string
	 */
	public function get_gradient_style( $args ) {
		$default_gradient = array(
			&#039;repeat&#039;           =&gt; ET_Global_Settings::get_value( &#039;all_background_gradient_repeat&#039; ),
			&#039;type&#039;             =&gt; ET_Global_Settings::get_value( &#039;all_background_gradient_type&#039; ),
			&#039;direction&#039;        =&gt; ET_Global_Settings::get_value( &#039;all_background_gradient_direction&#039; ),
			&#039;radial_direction&#039; =&gt; ET_Global_Settings::get_value( &#039;all_background_gradient_direction_radial&#039; ),
			&#039;stops&#039;            =&gt; ET_Global_Settings::get_value( &#039;all_background_gradient_stops&#039; ),
		);

		$defaults = apply_filters( &#039;et_pb_default_gradient&#039;, $default_gradient );
		$args     = wp_parse_args( array_filter( $args ), $defaults );
		$stops    = str_replace( &#039;|&#039;, &#039;, &#039;, $args[&#039;stops&#039;] );

		$stops = $this-&gt;get_color_value( $stops );

		switch ( $args[&#039;type&#039;] ) {
			case &#039;conic&#039;:
				$type      = &#039;conic&#039;;
				$direction = &quot;from {$args[&#039;direction&#039;]} at {$args[&#039;radial_direction&#039;]}&quot;;
				break;
			case &#039;elliptical&#039;:
				$type      = &#039;radial&#039;;
				$direction = &quot;ellipse at {$args[&#039;radial_direction&#039;]}&quot;;
				break;
			case &#039;radial&#039;:
			case &#039;circular&#039;:
				$type      = &#039;radial&#039;;
				$direction = &quot;circle at {$args[&#039;radial_direction&#039;]}&quot;;
				break;
			case &#039;linear&#039;:
			default:
				$type      = &#039;linear&#039;;
				$direction = $args[&#039;direction&#039;];
		}

		// Apply gradient repeat (if set).
		if ( &#039;on&#039; === $args[&#039;repeat&#039;] ) {
			$type = &quot;repeating-{$type}&quot;;
		}

		return esc_html(
			&quot;{$type}-gradient( {$direction}, {$stops} )&quot;
		);
	}

	/**
	 * Get individual background image style
	 *
	 * @since 4.3.3
	 * @since 4.15.0 deprecated
	 *
	 * @deprecated Use {@see get_attr_value} instead.
	 *
	 * @param string $attr                 Background attribute name.
	 * @param string $base_prop_name       Base background prop name.
	 * @param string $suffix               Attribute name suffix.
	 * @param array  $props                Module props.
	 * @param array  $fields_definition    Module&#039;s fields definition.
	 * @param bool   $is_prev_image_active Whether previous background image is active or not.
	 *
	 * @return string
	 */
	public function get_image_style( $attr, $base_prop_name, $suffix = &#039;&#039;, $props = array(), $fields_definition = array(), $is_prev_image_active = true ) {
		return $this-&gt;get_attr_value( $attr, $base_prop_name, $suffix = &#039;&#039;, $props, $fields_definition, $is_prev_image_active );
	}

	/**
	 * Get individual default value.
	 *
	 * @since 4.15.0
	 *
	 * @param string $attr                  Background attribute name.
	 * @param string $base_prop_name        Base background prop name.
	 * @param array  $fields_definition     Module&#039;s fields definition.
	 * @param bool   $is_prev_device_active Whether previous background image is active or not.
	 *
	 * @return string
	 */
	public function get_attr_default( $attr, $base_prop_name, $fields_definition = array(), $is_prev_device_active = true ) {
		$default = isset( $fields_definition[ &quot;{$base_prop_name}_{$attr}&quot; ][&#039;default&#039;] )
			? $fields_definition[ &quot;{$base_prop_name}_{$attr}&quot; ][&#039;default&#039;]
			: &#039;&#039;;

		return $is_prev_device_active ? $default : &#039;&#039;;
	}

	/**
	 * Get individual background attribute value.
	 *
	 * @since 4.15.0
	 *
	 * @param string $attr                 Background attribute name.
	 * @param string $base_prop_name       Base background prop name.
	 * @param string $suffix               Attribute name suffix.
	 * @param array  $props                Module props.
	 * @param array  $fields_definition    Module&#039;s fields definition.
	 * @param bool   $is_prev_device_active  Whether is active in previous device or not.
	 *
	 * @return string
	 */
	public function get_attr_value( $attr, $base_prop_name, $suffix = &#039;&#039;, $props = array(), $fields_definition = array(), $is_prev_device_active = true ) {
		$default = $this-&gt;get_attr_default( $attr, $base_prop_name, $fields_definition, $is_prev_device_active );

		return et_pb_responsive_options()-&gt;get_any_value( $props, &quot;{$base_prop_name}_{$attr}{$suffix}&quot;, $default, ! $is_prev_device_active );
	}

	/**
	 * Return CSS for Transform State.
	 *
	 * @since 4.15.0
	 *
	 * @param string $values Transform states.
	 * @param string $state  Query state, valid options: horizontal | vertical | rotate | invert.
	 *
	 * @return string
	 */
	public function get_transform_state( $values, $state ) {
		$flip = &#039;&#039; !== $values ? explode( &#039;|&#039;, $values ) : array();

		switch ( $state ) {
			case &#039;horizontal&#039;:
				$result = in_array( &#039;flip_horizontal&#039;, $flip, true );
				break;
			case &#039;invert&#039;:
				$result = in_array( &#039;invert&#039;, $flip, true );
				break;
			case &#039;rotate&#039;:
				$result = in_array( &#039;rotate_90_degree&#039;, $flip, true );
				break;
			case &#039;vertical&#039;:
				$result = in_array( &#039;flip_vertical&#039;, $flip, true );
				break;
			default:
				$result = false;
		}

		return $result;
	}

	/**
	 * Return CSS for Transform State.
	 *
	 * We use `scale` here because CSS Transform&#039;s `rotateX`/`rotateY` trigger a 10+
	 * year old Safari bug that hides rotated background images (including SVGs).
	 *
	 * @see https://bugs.webkit.org/show_bug.cgi?id=61824
	 *
	 * @since 4.15.0
	 *
	 * @param bool $horizontal Horizontal state.
	 * @param bool $vertical   Vertical state.
	 *
	 * @return string
	 */
	public function get_transform_css( $horizontal, $vertical ) {
		$flip_h = $horizontal ? &#039;-1&#039; : &#039;1&#039;;
		$flip_v = $vertical ? &#039;-1&#039; : &#039;1&#039;;

		return &quot;scale($flip_h, $flip_v)&quot;;
	}

	/**
	 * Helper function to return CSS for BackgroundPosition.
	 *
	 * @since 4.15.0
	 *
	 * @param string $position Position.
	 * @param string $horizontal_offset Horizontal Offset.
	 * @param string $vertical_offset Vertical Offset.
	 * @param string $position_default Default Position.
	 *
	 * @return array
	 */
	public function get_background_position_css( $position, $horizontal_offset, $vertical_offset, $position_default = &#039;&#039; ) {
		$position_value          = empty( $position ) ? $position_default : $position;
		$horizontal_offset_value = et_builder_process_range_value( $horizontal_offset );
		$vertical_offset_value   = et_builder_process_range_value( $vertical_offset );
		$position_array          = explode( &#039;_&#039;, $position_value );
		$output                  = array();

		// Vertical Offset.
		if ( isset( $position_array[0] ) ) {
			switch ( $position_array[0] ) {
				case &#039;top&#039;:
					// Top doesn&#039;t need suffix when value is 0.
					$output[&#039;position-y&#039;] = 0 === (int) $vertical_offset
						? $position_array[0]
						: &quot;{$position_array[0]} {$vertical_offset_value}&quot;;
					break;
				case &#039;bottom&#039;:
					$output[&#039;position-y&#039;] = &quot;{$position_array[0]} {$vertical_offset_value}&quot;;
					break;
				case &#039;center&#039;:
				default:
					$output[&#039;position-y&#039;] = &#039;center&#039;;
			}
		}

		// Horizontal Offset.
		if ( isset( $position_array[1] ) ) {
			switch ( $position_array[1] ) {
				case &#039;left&#039;:
					// Left doesn&#039;t need suffix when value is 0.
					$output[&#039;position-x&#039;] = 0 === (int) $horizontal_offset
						? $position_array[1]
						: &quot;{$position_array[1]} {$horizontal_offset_value}&quot;;
					break;
				case &#039;right&#039;:
					$output[&#039;position-x&#039;] = &quot;{$position_array[1]} {$horizontal_offset_value}&quot;;
					break;
				case &#039;center&#039;:
				default:
					$output[&#039;position-x&#039;] = &#039;center&#039;;
			}
		} else {
			// When $position_array[1] is absence.
			$output[&#039;position-x&#039;] = &#039;center&#039;;
		}

		// Prepare output for the CSS value.
		$output[&#039;position&#039;] = &#039;center&#039; === $output[&#039;position-x&#039;] &amp;&amp; &#039;center&#039; === $output[&#039;position-y&#039;]
			? &#039;center&#039;
			: &quot;{$output[&#039;position-x&#039;]} {$output[&#039;position-y&#039;]}&quot;;

		return $output;
	}

	/**
	 * Helper function to return CSS for BackgroundSize.
	 *
	 * @since 4.15.0
	 *
	 * @param string $size Size.
	 * @param string $width Width.
	 * @param string $height Vertical Offset.
	 * @param string $size_default Default Size.
	 * @param string $type Type, use to handle special case.
	 *
	 * @return array
	 */
	public function get_background_size_css( $size, $width, $height, $size_default = &#039;&#039;, $type = &#039;&#039; ) {
		$size_value = &#039;&#039; === $size ? $size_default : $size;
		$output     = array();

		switch ( $size_value ) {
			case &#039;custom&#039;:
				$is_width_auto  = &#039;auto&#039; === $width || &#039;&#039; === $width || 0 === (int) $width;
				$is_height_auto = &#039;auto&#039; === $height || &#039;&#039; === $height || 0 === (int) $height;
				$width_value    = $is_width_auto ? &#039;auto&#039; : et_builder_process_range_value( $width );
				$height_value   = $is_height_auto ? &#039;auto&#039; : et_builder_process_range_value( $height );

				if ( $is_width_auto &amp;&amp; $is_height_auto ) {
					$output[&#039;size&#039;] = &#039;initial&#039;;
				} else {
					$output[&#039;size&#039;] = &quot;{$width_value} {$height_value}&quot;;
				}
				break;
			case &#039;stretch&#039;:
				// For mask, increase 2px to resolve sub-pixel rendering issue in Chrome/Safari.
				$output[&#039;size&#039;] = &#039;mask&#039; === $type
					? &#039;calc(100% + 2px) calc(100% + 2px)&#039;
					: &#039;100% 100%&#039;;
				break;
			case &#039;cover&#039;:
			case &#039;contain&#039;:
			case &#039;initial&#039;:
				$output[&#039;size&#039;] = $size_value;
				break;
			default:
				$output[&#039;size&#039;] = &#039;&#039;;
		}

		return $output;
	}

	/**
	 * Get background UI option&#039;s style based on given props and prop name
	 *
	 * @since 4.3.3
	 * @since 4.6.0 Add sticky style support.
	 * @since 4.15.0 Add pattern/mask style support.
	 *
	 * @todo Further simplify this method; Break it down into more encapsulated methods
	 *
	 * @param array $args {
	 *     @type string $base_prop_name
	 *     @type array  $props
	 *     @type string $important
	 *     @type array  $fields_Definition
	 *     @type string $selector
	 *     @type string $selector_hover
	 *     @type string $selector_sticky
	 *     @type number $priority
	 *     @type string $function_name
	 *     @type bool   $has_background_color_toggle
	 *     @type bool   $use_background_color
	 *     @type bool   $use_background_color_gradient
	 *     @type bool   $use_background_image
	 *     @type bool   $use_background_video
	 *     @type bool   $use_background_pattern
	 *     @type bool   $use_background_mask
	 *     @type bool   $use_background_color_reset
	 *     @type bool   $use_background_image_parallax
	 * }
	 */
	public function get_background_style( $args = array() ) {
		// Default settings.
		$defaults = array(
			&#039;base_prop_name&#039;                =&gt; &#039;background&#039;,
			&#039;props&#039;                         =&gt; array(),
			&#039;important&#039;                     =&gt; &#039;&#039;,
			&#039;fields_definition&#039;             =&gt; array(),
			&#039;selector&#039;                      =&gt; &#039;&#039;,
			&#039;selector_hover&#039;                =&gt; &#039;&#039;,
			&#039;selector_sticky&#039;               =&gt; &#039;&#039;,
			&#039;selector_pattern&#039;              =&gt; &#039;&#039;,
			&#039;selector_mask&#039;                 =&gt; &#039;&#039;,
			&#039;priority&#039;                      =&gt; &#039;&#039;,
			&#039;function_name&#039;                 =&gt; &#039;&#039;,
			&#039;has_background_color_toggle&#039;   =&gt; false,
			&#039;use_background_color&#039;          =&gt; true,
			&#039;use_background_color_gradient&#039; =&gt; true,
			&#039;use_background_image&#039;          =&gt; true,
			&#039;use_background_video&#039;          =&gt; true,
			&#039;use_background_color_reset&#039;    =&gt; true,
			&#039;use_background_pattern&#039;        =&gt; true,
			&#039;use_background_mask&#039;           =&gt; true,
			&#039;use_background_image_parallax&#039; =&gt; true,
			&#039;prop_name_aliases&#039;             =&gt; array(),
		);

		// Parse arguments.
		$args = wp_parse_args( $args, $defaults );

		// Break argument into variables.
		$base_prop_name    = $args[&#039;base_prop_name&#039;];
		$props             = $args[&#039;props&#039;];
		$important         = $args[&#039;important&#039;];
		$fields_definition = $args[&#039;fields_definition&#039;];
		$selector          = $args[&#039;selector&#039;];
		$selector_pattern  = $args[&#039;selector_pattern&#039;];
		$selector_mask     = $args[&#039;selector_mask&#039;];
		$priority          = $args[&#039;priority&#039;];
		$function_name     = $args[&#039;function_name&#039;];

		// Possible values for use_background_* variables are true, false, or &#039;fields_only&#039;.
		$has_color_toggle_options = $args[&#039;has_background_color_toggle&#039;];
		$use_gradient_options     = $args[&#039;use_background_color_gradient&#039;];
		$use_image_options        = $args[&#039;use_background_image&#039;];
		$use_color_options        = $args[&#039;use_background_color&#039;];
		$use_color_reset_options  = $args[&#039;use_background_color_reset&#039;];
		$use_pattern_options      = $args[&#039;use_background_pattern&#039;];
		$use_mask_options         = $args[&#039;use_background_mask&#039;];

		// Prop name aliases. Some background element uses different prop name (eg. button background).
		$prop_name_aliases = $args[&#039;prop_name_aliases&#039;];

		// Save processed background. These will be compared with the smaller device background
		// processed value to avoid rendering the same styles.
		$processed_color                 = &#039;&#039;;
		$gradient_properties_desktop     = array();
		$gradient_overlays_image_desktop = &#039;off&#039;;

		// Store background images status because the process is extensive.
		$image_status                   = $this-&gt;get_default_mode_status();
		$processed_image_size_style     = array( &#039;size&#039; =&gt; $this-&gt;get_attr_default( &#039;size&#039;, $base_prop_name, $fields_definition ) );
		$processed_image                = &#039;&#039;;
		$processed_image_position_style = &#039;&#039;;
		$processed_image_blend_style    = &#039;&#039;;

		// Background pattern.
		$pattern_base_prop_name            = &quot;{$base_prop_name}_pattern&quot;;
		$pattern_status                    = $this-&gt;get_default_mode_status();
		$processed_pattern_transform_style = &#039;&#039;;
		$processed_pattern_svg             = &#039;&#039;;
		$processed_pattern_size_style      = array( &#039;size&#039; =&gt; $this-&gt;get_attr_default( &#039;size&#039;, $pattern_base_prop_name, $fields_definition ) );
		$processed_pattern_position_style  = &#039;&#039;;

		// Background mask.
		$mask_base_prop_name            = &quot;{$base_prop_name}_mask&quot;;
		$mask_status                    = $this-&gt;get_default_mode_status();
		$processed_mask_transform_style = &#039;&#039;;
		$processed_mask_svg             = &#039;&#039;;
		$processed_mask_size_style      = array( &#039;size&#039; =&gt; $this-&gt;get_attr_default( &#039;size&#039;, $mask_base_prop_name, $fields_definition ) );
		$processed_mask_position_style  = &#039;&#039;;

		// Helper.
		$feature_manager = ET_Builder_Module_Features::instance();
		$responsive      = et_pb_responsive_options();

		/**
		 * Module Component.
		 *
		 * @var ET_Builder_Element $module
		 */
		$module = isset( $args[&#039;module&#039;] ) ? $args[&#039;module&#039;] : ET_Builder_Element::get_module( $function_name );

		// Bail, there is nothing to process.
		// Happens when et_pb_posts module don&#039;t find a $post to process.
		if ( is_string( $module ) || ! ( $module &amp;&amp; $module instanceof ET_Builder_Element ) ) {
			return;
		}

		// We got the module, get unprocessed attrs.
		$attrs_unprocessed = $module-&gt;get_attrs_unprocessed();

		// Get dynamic attributes.
		$dynamic_attributes = $this-&gt;_get_enabled_dynamic_attributes( $props );

		// Parsed prop name, in case it has aliases.
		$base_prop_name_parsed = $this-&gt;get_prop_name_alias( $prop_name_aliases, $base_prop_name );

		// Background Desktop, Tablet, and Phone.
		foreach ( $responsive-&gt;get_modes() as $device ) {
			$is_desktop = &#039;desktop&#039; === $device;
			$suffix     = ! $is_desktop ? &quot;_{$device}&quot; : &#039;&#039;;
			$style      = &#039;&#039;;

			$style_pattern = &#039;&#039;;
			$style_mask    = &#039;&#039;;

			// Conditionals.
			$has_gradient           = false;
			$has_image              = false;
			$has_gradient_and_image = false;
			$is_gradient_disabled   = false;
			$is_image_disabled      = false;

			$is_enabled = $feature_manager-&gt;get(
			// Is background responsive enabled for $device.
			// keys: bared, baret, barep.
				&#039;bare&#039; . $device[0],
				function() use ( $responsive, $base_prop_name_parsed, $props ) {
					return $responsive-&gt;is_responsive_enabled( $props, $base_prop_name_parsed );
				}
			);

			// Ensure responsive settings is enabled on mobile.
			if ( ! $is_desktop &amp;&amp; ! $is_enabled ) {
				continue;
			}

			// Styles output.
			$image_style             = &#039;&#039;;
			$color_style             = &#039;&#039;;
			$images                  = array();
			$gradient_overlays_image = &#039;off&#039;;

			$image_size_style        = &#039;&#039;;
			$image_position_style    = &#039;&#039;;
			$pattern_transform_style = &#039;&#039;;
			$pattern_style_svg       = &#039;&#039;;
			$pattern_size_style      = &#039;&#039;;
			$pattern_position_style  = &#039;&#039;;
			$mask_transform_style    = &#039;&#039;;
			$mask_style_svg          = &#039;&#039;;
			$mask_size_style         = &#039;&#039;;
			$mask_position_style     = &#039;&#039;;

			// A. Background Gradient.
			if ( $use_gradient_options &amp;&amp; &#039;fields_only&#039; !== $use_gradient_options ) {
				$use_gradient = $responsive-&gt;get_inheritance_background_value(
					$props,
					$this-&gt;get_prop_name_alias( $prop_name_aliases, &quot;use_{$base_prop_name}_color_gradient&quot; ),
					$device,
					$base_prop_name,
					$fields_definition
				);

				// 1. Ensure gradient color is active.
				if ( &#039;on&#039; === $use_gradient ) {
					$gradient_overlays_image = $responsive-&gt;get_any_value( $props, &quot;{$base_prop_name}_color_gradient_overlays_image{$suffix}&quot;, &#039;&#039;, true );
					$gradient_properties     = $this-&gt;get_gradient_properties( $props, $base_prop_name, $suffix );

					// Will be used as default of Gradient hover.
					if ( $is_desktop ) {
						$gradient_properties_desktop     = $gradient_properties;
						$gradient_overlays_image_desktop = $gradient_overlays_image;
					}

					// Save background gradient into background images list.
					$background_gradient = $this-&gt;get_gradient_style( $gradient_properties );
					$images[]            = $background_gradient;

					// Flag to inform Background Color if current module has Gradient.
					$has_gradient = true;
				} elseif ( &#039;off&#039; === $use_gradient ) {
					$is_gradient_disabled = true;
				}
			}

			// B. Background Image.
			if ( $use_image_options &amp;&amp; &#039;fields_only&#039; !== $use_image_options ) {
				$image    = $responsive-&gt;get_inheritance_background_value( $props, &quot;{$base_prop_name}_image&quot;, $device, $base_prop_name, $fields_definition );
				$parallax = $responsive-&gt;get_any_value( $props, &quot;parallax{$suffix}&quot;, &#039;off&#039; );

				// Determine whether force inline styles.
				if ( ! ET_Builder_Element::$forced_inline_styles ) {
					$background_image_field = $responsive-&gt;get_field_name( &quot;{$base_prop_name}_image&quot;, $device );
					$raw                    = isset( $attrs_unprocessed[ $background_image_field ] ) ? $attrs_unprocessed[ $background_image_field ] : &#039;&#039;;
					if ( $this-&gt;_is_dynamic_value( $background_image_field, $raw, $dynamic_attributes ) ) {
						ET_Builder_Element::$forced_inline_styles = true;
					}
				}

				// Featured image as background is in higher priority.
				if ( $module-&gt;featured_image_background ) {
					$featured_image         = isset( $props[&#039;featured_image&#039;] ) ? $props[&#039;featured_image&#039;] : &#039;&#039;;
					$featured_placement     = isset( $props[&#039;featured_placement&#039;] ) ? $props[&#039;featured_placement&#039;] : &#039;&#039;;
					$featured_image_src_obj = wp_get_attachment_image_src( get_post_thumbnail_id( self::_get_main_post_id() ), &#039;full&#039; );
					$featured_image_src     = isset( $featured_image_src_obj[0] ) ? $featured_image_src_obj[0] : &#039;&#039;;

					if ( &#039;on&#039; === $featured_image &amp;&amp; &#039;background&#039; === $featured_placement &amp;&amp; &#039;&#039; !== $featured_image_src ) {
						$image = $featured_image_src;
					}
				}

				// Background image and parallax status.
				$is_image_active         = &#039;&#039; !== $image &amp;&amp; &#039;on&#039; !== $parallax;
				$image_status[ $device ] = $is_image_active;

				// 1. Ensure image exists and parallax is off.
				if ( $is_image_active ) {
					// Flag to inform Background Color if current module has Image.
					$has_image = true;

					// Check previous Background image status. Needed to get the correct value.
					$is_prev_image_active = true;

					if ( ! $is_desktop ) {
						$is_prev_image_active = &#039;tablet&#039; === $device ?
							$image_status[&#039;desktop&#039;] :
							$image_status[&#039;tablet&#039;];
					}

					// Size.
					$image_size_default   = $this-&gt;get_attr_default( &#039;size&#039;, $base_prop_name, $fields_definition );
					$image_size_inherit   = $this-&gt;get_attr_value( &#039;size&#039;, $base_prop_name, $suffix, $props, $fields_definition, false );
					$image_width_inherit  = $this-&gt;get_attr_value( &#039;image_width&#039;, $base_prop_name, $suffix, $props, $fields_definition, false );
					$image_height_inherit = $this-&gt;get_attr_value( &#039;image_height&#039;, $base_prop_name, $suffix, $props, $fields_definition, false );

					if ( &#039;&#039; !== $image_size_inherit || $image_width_inherit || $image_height_inherit ) {
						// Get Size CSS.
						$image_size_style = $this-&gt;get_background_size_css( $image_size_inherit, $image_width_inherit, $image_height_inherit, $image_size_default, &#039;image&#039; );

						// Set image background size styles only it&#039;s different compared to the larger device.
						if ( $processed_image_size_style !== $image_size_style ) {
							if ( isset( $image_size_style[&#039;size&#039;] ) &amp;&amp; $image_size_style[&#039;size&#039;] ) {
								$style .= sprintf(
									&#039;background-size: %1$s; &#039;,
									esc_html( $image_size_style[&#039;size&#039;] )
								);
							}
						}
					}

					// Check if image size has &#039;stretch&#039; value or not.
					$is_image_size_stretch = &#039;stretch&#039; === $this-&gt;get_attr_value( &#039;size&#039;, $base_prop_name, $suffix, $props, $fields_definition, false );

					// Repeat.
					$image_repeat = $this-&gt;get_attr_value( &#039;repeat&#039;, $base_prop_name, $suffix, $props, $fields_definition, $is_prev_image_active );

					// Print image repeat when image size is not &#039;stretch&#039;.
					if ( ! $is_image_size_stretch &amp;&amp; &#039;&#039; !== $image_repeat ) {
						$style .= sprintf( &#039;background-repeat: %1$s; &#039;, esc_html( $image_repeat ) );
					}

					// Position.
					$image_position_default          = $this-&gt;get_attr_default( &quot;{$base_prop_name}_position{$suffix}&quot;, $base_prop_name, $fields_definition );
					$image_position_inherit          = $this-&gt;get_attr_value( &#039;position&#039;, $base_prop_name, $suffix, $props, $fields_definition, $is_prev_image_active );
					$image_horizontal_offset_inherit = $this-&gt;get_attr_value( &#039;horizontal_offset&#039;, $base_prop_name, $suffix, $props, $fields_definition, $is_prev_image_active );
					$image_vertical_offset_inherit   = $this-&gt;get_attr_value( &#039;vertical_offset&#039;, $base_prop_name, $suffix, $props, $fields_definition, $is_prev_image_active );

					// Check if image repeat has &#039;space&#039; value or not.
					$is_image_repeat_space = &#039;space&#039; === $this-&gt;get_attr_value( &#039;repeat&#039;, $base_prop_name, $suffix, $props, $fields_definition, false );

					// Print image repeat origin/offset when image size is not &#039;stretch&#039;, and
					// image repeat is not &#039;space&#039;.
					if (
						! $is_image_size_stretch
						&amp;&amp; ! $is_image_repeat_space
						&amp;&amp; ( &#039;&#039; !== $image_position_inherit || $image_horizontal_offset_inherit || $image_vertical_offset_inherit )
					) {
						// Get Position CSS.
						$image_position_style = $this-&gt;get_background_position_css( $image_position_inherit, $image_horizontal_offset_inherit, $image_vertical_offset_inherit, $image_position_default );

						// Set background image position styles only it&#039;s different compared to the larger device.
						if ( $processed_image_position_style !== $image_position_style ) {
							$style .= sprintf(
								&#039;background-position: %1$s; &#039;,
								esc_html( $image_position_style[&#039;position&#039;] )
							);
						}
					}

					// Blend.
					$image_blend_inherit = $this-&gt;get_attr_value( &#039;blend&#039;, $base_prop_name, $suffix, $props, $fields_definition, $is_prev_image_active );
					$image_blend_default = $this-&gt;get_attr_default( &#039;blend&#039;, $base_prop_name, $fields_definition );

					if ( &#039;&#039; !== $image_blend_inherit ) {
						// Don&#039;t print the same image blend style.
						if ( $processed_image_blend_style !== $image_blend_inherit ) {
							$style .= sprintf( &#039;background-blend-mode: %1$s; &#039;, esc_html( $image_blend_inherit ) );
						}

						// Reset - If background has image and gradient, force background-color: initial.
						if ( $has_gradient &amp;&amp; &#039;fields_only&#039; !== $use_color_reset_options &amp;&amp; $image_blend_inherit !== $image_blend_default ) {
							$has_gradient_and_image = true;
							$color_style            = &#039;initial&#039;;

							$style .= sprintf( &#039;background-color: initial%1$s; &#039;, esc_html( $important ) );
						}

						$processed_image_blend_style = $image_blend_inherit;
					}

					// Only append background image when the image is exist.
					$images[] = sprintf( &#039;url(%1$s)&#039;, esc_html( $image ) );
				} elseif ( &#039;&#039; === $image ) {
					// Reset - If background image is disabled, ensure we reset prev background blend mode.
					if ( &#039;&#039; !== $processed_image_blend_style ) {
						$style                      .= &#039;background-blend-mode: normal; &#039;;
						$processed_image_blend_style = &#039;&#039;;
					}

					$is_image_disabled = true;
				}
			}

			if ( ! empty( $images ) ) {
				// Check if Parallax and Gradient Overlays are on.
				$gradient_overlays_image = $responsive-&gt;get_any_value( $props, &quot;{$base_prop_name}_color_gradient_overlays_image{$suffix}&quot;, &#039;off&#039;, true );
				$parallax                = $responsive-&gt;get_any_value( $props, &quot;parallax{$suffix}&quot;, &#039;off&#039;, true );

				// The browsers stack the images in the opposite order to what you&#039;d expect.
				if ( &#039;on&#039; !== $gradient_overlays_image ) {
					$images = array_reverse( $images );
				}

				if ( $use_gradient_options &amp;&amp; &#039;on&#039; === $gradient_overlays_image &amp;&amp; &#039;on&#039; === $parallax ) {
					// Set background image to initial when Parallax and Gradient Overlays are on.
					$image_style = &#039;initial&#039;;
				} else {
					// Set background image styles only it&#039;s different compared to the larger device.
					$image_style = join( &#039;, &#039;, $images );
				}

				if ( $processed_image !== $image_style ) {
					$style .= sprintf(
						&#039;background-image: %1$s%2$s;&#039;,
						esc_html( $image_style ),
						$important
					);
				}
			} elseif ( ! $is_desktop &amp;&amp; $is_gradient_disabled &amp;&amp; $is_image_disabled ) {
				// Reset - If background image and gradient are disabled, reset current background image.
				$image_style = &#039;initial&#039;;

				$style .= sprintf(
					&#039;background-image: %1$s%2$s;&#039;,
					esc_html( $image_style ),
					$important
				);
			}

			// Save processed background images.
			$processed_image = $image_style;

			// Save processed styles.
			$processed_image_size_style     = $image_size_style;
			$processed_image_position_style = $image_position_style;

			// C. Background Color.
			if ( $use_color_options &amp;&amp; &#039;fields_only&#039; !== $use_color_options ) {

				$use_color_value = $responsive-&gt;get_any_value( $props, &quot;use_{$base_prop_name}_color{$suffix}&quot;, &#039;on&#039;, true );

				if ( ! $has_gradient_and_image &amp;&amp; &#039;off&#039; !== $use_color_value ) {
					$color       = $responsive-&gt;get_inheritance_background_value( $props, &quot;{$base_prop_name}_color&quot;, $device, $base_prop_name, $fields_definition );
					$color       = ! $is_desktop &amp;&amp; &#039;&#039; === $color ? &#039;initial&#039; : $color;
					$color_style = $color;

					if ( &#039;&#039; !== $color &amp;&amp; $processed_color !== $color ) {
						$style .= sprintf(
							&#039;background-color: %1$s%2$s; &#039;,
							esc_html( $this-&gt;get_color_value( $color ) ),
							esc_html( $important )
						);
					}
				} elseif ( $has_color_toggle_options &amp;&amp; &#039;off&#039; === $use_color_value &amp;&amp; ! $is_desktop ) {
					// Reset - If current module has background color toggle, it&#039;s off, and current mode
					// it&#039;s not desktop, we should reset the background color.
					$style .= sprintf(
						&#039;background-color: initial %1$s; &#039;,
						esc_html( $important )
					);
				}
			}

			// Save processed background color.
			$processed_color = $color_style;

			// E. Background Pattern.
			if ( $use_pattern_options &amp;&amp; &#039;fields_only&#039; !== $use_pattern_options ) {
				$pattern_style_name = $responsive-&gt;get_inheritance_background_value( $props, &quot;{$pattern_base_prop_name}_style&quot;, $device, $base_prop_name, $fields_definition );

				$is_pattern_active         = &#039;&#039; !== $pattern_style_name;
				$pattern_status[ $device ] = $is_pattern_active;

				if ( $is_pattern_active ) {
					// Check previous pattern status. Needed to get the correct value.
					$is_prev_pattern_active = true;
					if ( ! $is_desktop ) {
						$is_prev_pattern_active = &#039;tablet&#039; === $device ? $pattern_status[&#039;desktop&#039;] : $pattern_status[&#039;tablet&#039;];
					}

					// Pattern Transform.
					$pattern_transform_inherit = $responsive-&gt;get_any_value( $props, &quot;{$pattern_base_prop_name}_transform{$suffix}&quot;, &#039;&#039;, true );

					$pattern_is_horizontal   = $this-&gt;get_transform_state( $pattern_transform_inherit, &#039;horizontal&#039; );
					$pattern_is_vertical     = $this-&gt;get_transform_state( $pattern_transform_inherit, &#039;vertical&#039; );
					$pattern_is_rotated      = $this-&gt;get_transform_state( $pattern_transform_inherit, &#039;rotate&#039; );
					$pattern_is_inverted     = $this-&gt;get_transform_state( $pattern_transform_inherit, &#039;invert&#039; );
					$pattern_transform_style = $this-&gt;get_transform_css( $pattern_is_horizontal, $pattern_is_vertical );

					$is_pattern_transform_style_different = $processed_pattern_transform_style !== $pattern_transform_style;

					if ( $is_pattern_transform_style_different &amp;&amp; ( $pattern_is_horizontal || $pattern_is_vertical ) ) {
						$style_pattern .= sprintf(
							&#039;transform: %1$s; &#039;,
							esc_html( $pattern_transform_style )
						);
					} elseif ( $is_pattern_transform_style_different &amp;&amp; ! $is_desktop ) {
						$style_pattern .= sprintf(
							&#039;transform: %1$s; &#039;,
							esc_html( $pattern_transform_style )
						);
					}

					// Pattern Image.
					$pattern_color     = $responsive-&gt;get_any_value( $props, &quot;{$pattern_base_prop_name}_color{$suffix}&quot;, &#039;&#039;, true );
					$pattern_style_svg = et_pb_background_pattern_options()-&gt;get_svg( $pattern_style_name, $pattern_color, &#039;default&#039;, $pattern_is_rotated, $pattern_is_inverted );

					// Set pattern style when it&#039;s different compared to the larger device.
					if ( $processed_pattern_svg !== $pattern_style_svg ) {
						$style_pattern .= sprintf(
							&#039;background-image: %1$s; &#039;,
							esc_html( $pattern_style_svg )
						);
					}

					// Pattern Size.
					$pattern_size_default   = $this-&gt;get_attr_default( &#039;size&#039;, $pattern_base_prop_name, $fields_definition );
					$pattern_size_inherit   = $this-&gt;get_attr_value( &#039;size&#039;, $pattern_base_prop_name, $suffix, $props, $fields_definition, $is_prev_pattern_active );
					$pattern_width_inherit  = $this-&gt;get_attr_value( &#039;width&#039;, $pattern_base_prop_name, $suffix, $props, $fields_definition, $is_prev_pattern_active );
					$pattern_height_inherit = $this-&gt;get_attr_value( &#039;height&#039;, $pattern_base_prop_name, $suffix, $props, $fields_definition, $is_prev_pattern_active );

					if ( &#039;&#039; !== $pattern_size_inherit || $pattern_width_inherit || $pattern_height_inherit ) {
						// Get Size CSS.
						$pattern_size_style = $this-&gt;get_background_size_css( $pattern_size_inherit, $pattern_width_inherit, $pattern_height_inherit, $pattern_size_default );

						// Set pattern background size styles only it&#039;s different compared to the larger device.
						if ( $processed_pattern_size_style !== $pattern_size_style ) {
							if ( isset( $pattern_size_style[&#039;size&#039;] ) &amp;&amp; $pattern_size_style[&#039;size&#039;] ) {
								$style_pattern .= sprintf(
									&#039;background-size: %1$s; &#039;,
									esc_html( $pattern_size_style[&#039;size&#039;] )
								);
							}
						}
					}

					// Check if pattern size has &#039;stretch&#039; value or not.
					$is_pattern_size_stretch = &#039;stretch&#039; === $this-&gt;get_attr_value( &#039;size&#039;, $pattern_base_prop_name, $suffix, $props, $fields_definition, false );

					// Pattern Repeat.
					$pattern_repeat_inherit = $this-&gt;get_attr_value( &#039;repeat&#039;, $pattern_base_prop_name, $suffix, $props, $fields_definition, $is_prev_pattern_active );

					// Print pattern repeat when pattern size is not &#039;stretch&#039;.
					if ( ! $is_pattern_size_stretch &amp;&amp; &#039;&#039; !== $pattern_repeat_inherit ) {
						$style_pattern .= sprintf(
							&#039;background-repeat: %1$s; &#039;,
							esc_html( $pattern_repeat_inherit )
						);
					}

					// Pattern Repeat Origin.
					$pattern_position_default          = $this-&gt;get_attr_default( &#039;repeat_origin&#039;, $pattern_base_prop_name, $fields_definition );
					$pattern_position_inherit          = $this-&gt;get_attr_value( &#039;repeat_origin&#039;, $pattern_base_prop_name, $suffix, $props, $fields_definition, $is_prev_pattern_active );
					$pattern_horizontal_offset_inherit = $this-&gt;get_attr_value( &#039;horizontal_offset&#039;, $pattern_base_prop_name, $suffix, $props, $fields_definition, $is_prev_pattern_active );
					$pattern_vertical_offset_inherit   = $this-&gt;get_attr_value( &#039;vertical_offset&#039;, $pattern_base_prop_name, $suffix, $props, $fields_definition, $is_prev_pattern_active );

					// Check if pattern repeat has &#039;space&#039; value or not.
					$is_pattern_repeat_space = &#039;space&#039; === $this-&gt;get_attr_value( &#039;repeat&#039;, $pattern_base_prop_name, $suffix, $props, $fields_definition, false );

					// Print pattern repeat origin/offset when pattern size is not &#039;stretch&#039;, and
					// pattern repeat is not &#039;space&#039;.
					if (
						! $is_pattern_size_stretch
						&amp;&amp; ! $is_pattern_repeat_space
						&amp;&amp; ( &#039;&#039; !== $pattern_position_inherit || $pattern_horizontal_offset_inherit || $pattern_vertical_offset_inherit )
					) {
						// Get Position CSS.
						$pattern_position_style = $this-&gt;get_background_position_css( $pattern_position_inherit, $pattern_horizontal_offset_inherit, $pattern_vertical_offset_inherit, $pattern_position_default );

						// Set background pattern position styles only it&#039;s different compared to the larger device.
						if ( $processed_pattern_position_style !== $pattern_position_style ) {
							$style_pattern .= sprintf(
								&#039;background-position: %1$s; &#039;,
								esc_html( $pattern_position_style[&#039;position&#039;] )
							);
						}
					}

					// Pattern Blend Mode.
					$pattern_blend_inherit = $this-&gt;get_attr_value( &#039;blend_mode&#039;, $pattern_base_prop_name, $suffix, $props, $fields_definition, $is_prev_pattern_active );

					if ( &#039;&#039; !== $pattern_blend_inherit ) {
						$style_pattern .= sprintf(
							&#039;mix-blend-mode: %1$s; &#039;,
							esc_html( $pattern_blend_inherit )
						);
					}
				} elseif ( ! $is_desktop &amp;&amp; $processed_pattern_svg !== $pattern_style_svg ) {
					// Reset pattern image.
					$pattern_style_svg = &#039;initial&#039;;
					$style_pattern    .= sprintf(
						&#039;background-image: %1$s; &#039;,
						esc_html( $pattern_style_svg )
					);
				}
			}

			// Save processed styles.
			$processed_pattern_transform_style = $pattern_transform_style;
			$processed_pattern_svg             = $pattern_style_svg;
			$processed_pattern_size_style      = $pattern_size_style;
			$processed_pattern_position_style  = $pattern_position_style;

			// F. Background Mask.
			if ( $use_mask_options &amp;&amp; &#039;fields_only&#039; !== $use_mask_options ) {
				$mask_style_name = $responsive-&gt;get_inheritance_background_value( $props, &quot;{$mask_base_prop_name}_style&quot;, $device, $base_prop_name, $fields_definition );

				$is_mask_active         = &#039;&#039; !== $mask_style_name;
				$mask_status[ $device ] = $is_mask_active;

				if ( $is_mask_active ) {
					// Check previous mask status. Needed to get the correct value.
					$is_prev_mask_active = true;
					if ( ! $is_desktop ) {
						$is_prev_mask_active = &#039;tablet&#039; === $device ? $mask_status[&#039;desktop&#039;] : $mask_status[&#039;tablet&#039;];
					}

					// Mask Transform.
					$mask_transform_inherit = $responsive-&gt;get_any_value( $props, &quot;{$mask_base_prop_name}_transform{$suffix}&quot;, &#039;&#039;, true );

					$mask_is_horizontal   = $this-&gt;get_transform_state( $mask_transform_inherit, &#039;horizontal&#039; );
					$mask_is_vertical     = $this-&gt;get_transform_state( $mask_transform_inherit, &#039;vertical&#039; );
					$mask_is_rotated      = $this-&gt;get_transform_state( $mask_transform_inherit, &#039;rotate&#039; );
					$mask_is_inverted     = $this-&gt;get_transform_state( $mask_transform_inherit, &#039;invert&#039; );
					$mask_transform_style = $this-&gt;get_transform_css( $mask_is_horizontal, $mask_is_vertical );

					$is_mask_transform_style_different = $processed_mask_transform_style !== $mask_transform_style;

					if ( $is_mask_transform_style_different &amp;&amp; ( $mask_is_horizontal || $mask_is_vertical ) ) {
						$style_mask .= sprintf(
							&#039;transform: %1$s; &#039;,
							esc_html( $mask_transform_style )
						);
					} elseif ( $is_mask_transform_style_different &amp;&amp; ! $is_desktop ) {
						$style_mask .= sprintf(
							&#039;transform: %1$s; &#039;,
							esc_html( $mask_transform_style )
						);
					}

					// Mask Size.
					$mask_size_default   = $this-&gt;get_attr_default( &#039;size&#039;, $mask_base_prop_name, $fields_definition );
					$mask_size_inherit   = $this-&gt;get_attr_value( &#039;size&#039;, $mask_base_prop_name, $suffix, $props, $fields_definition, $is_prev_mask_active );
					$mask_width_inherit  = $this-&gt;get_attr_value( &#039;width&#039;, $mask_base_prop_name, $suffix, $props, $fields_definition, $is_prev_mask_active );
					$mask_height_inherit = $this-&gt;get_attr_value( &#039;height&#039;, $mask_base_prop_name, $suffix, $props, $fields_definition, $is_prev_mask_active );

					if ( &#039;&#039; !== $mask_size_inherit || ( $mask_width_inherit || $mask_height_inherit ) ) {
						// Get Size CSS.
						$mask_size_style = $this-&gt;get_background_size_css( $mask_size_inherit, $mask_width_inherit, $mask_height_inherit, $mask_size_default, &#039;mask&#039; );

						// Set mask background size styles only it&#039;s different compared to the larger device.
						if ( $processed_mask_size_style !== $mask_size_style ) {
							if ( isset( $mask_size_style[&#039;size&#039;] ) &amp;&amp; $mask_size_style[&#039;size&#039;] ) {
								$style_mask .= sprintf(
									&#039;background-size: %1$s; &#039;,
									esc_html( $mask_size_style[&#039;size&#039;] )
								);
							}
						}
					}

					// Check if mask size has &#039;stretch&#039; value or not.
					$is_mask_size_stretch = &#039;stretch&#039; === $mask_size_inherit;

					// Set background mask style only it&#039;s different compared to the larger device.
					$mask_color     = $responsive-&gt;get_any_value( $props, &quot;{$mask_base_prop_name}_color{$suffix}&quot;, &#039;&#039;, true );
					$mask_ratio     = $responsive-&gt;get_any_value( $props, &quot;{$mask_base_prop_name}_aspect_ratio{$suffix}&quot;, &#039;&#039;, true );
					$mask_style_svg = et_pb_background_mask_options()-&gt;get_svg( $mask_style_name, $mask_color, $mask_ratio, $mask_is_rotated, $mask_is_inverted, $mask_size_inherit );

					if ( $processed_mask_svg !== $mask_style_svg ) {
						$style_mask .= sprintf(
							&#039;background-image: %1$s; &#039;,
							esc_html( $mask_style_svg )
						);
					}

					// Mask Position.
					$mask_position_default          = $responsive-&gt;get_any_value( $props, &quot;{$mask_base_prop_name}_position{$suffix}&quot;, &#039;&#039;, true );
					$mask_position_inherit          = $this-&gt;get_attr_value( &#039;position&#039;, $mask_base_prop_name, $suffix, $props, $fields_definition, $is_prev_mask_active );
					$mask_horizontal_offset_inherit = $this-&gt;get_attr_value( &#039;horizontal_offset&#039;, $mask_base_prop_name, $suffix, $props, $fields_definition, $is_prev_mask_active );
					$mask_vertical_offset_inherit   = $this-&gt;get_attr_value( &#039;vertical_offset&#039;, $mask_base_prop_name, $suffix, $props, $fields_definition, $is_prev_mask_active );

					if ( ! $is_mask_size_stretch &amp;&amp; ( &#039;&#039; !== $mask_position_inherit || $mask_horizontal_offset_inherit || $mask_vertical_offset_inherit ) ) {
						// Get Position CSS.
						$mask_position_style = $this-&gt;get_background_position_css( $mask_position_inherit, $mask_horizontal_offset_inherit, $mask_vertical_offset_inherit, $mask_position_default );

						// Set background mask position styles only it&#039;s different compared to the larger device.
						if ( $processed_mask_position_style !== $mask_position_style ) {
							$style_mask .= sprintf(
								&#039;background-position: %1$s; &#039;,
								esc_html( $mask_position_style[&#039;position&#039;] )
							);
						}
					}

					// Mask Blend Mode.
					$mask_blend_inherit = $this-&gt;get_attr_value( &#039;blend_mode&#039;, $mask_base_prop_name, $suffix, $props, $fields_definition, $is_prev_mask_active );

					if ( &#039;&#039; !== $mask_blend_inherit ) {
						$style_mask .= sprintf(
							&#039;mix-blend-mode: %1$s; &#039;,
							esc_html( $mask_blend_inherit )
						);
					}
				} elseif ( ! $is_desktop &amp;&amp; $processed_mask_svg !== $mask_style_svg ) {
					// Reset mask image.
					$mask_style_svg = &#039;initial&#039;;
					$style_mask    .= sprintf(
						&#039;background-image: %1$s; &#039;,
						esc_html( $mask_style_svg )
					);
				}
			}

			// Save processed styles.
			$processed_mask_transform_style = $mask_transform_style;
			$processed_mask_svg             = $mask_style_svg;
			$processed_mask_size_style      = $mask_size_style;
			$processed_mask_position_style  = $mask_position_style;

			// Add media query parameter.
			$background_args = array();
			if ( ! $is_desktop ) {
				$current_media_query            = &#039;tablet&#039; === $device ? &#039;max_width_980&#039; : &#039;max_width_767&#039;;
				$background_args[&#039;media_query&#039;] = ET_Builder_Element::get_media_query( $current_media_query );
			}

			// Render background styles.
			if ( &#039;&#039; !== $style ) {
				$el_style = array(
					&#039;selector&#039;    =&gt; $selector,
					&#039;declaration&#039; =&gt; rtrim( $style ),
					&#039;priority&#039;    =&gt; $module-&gt;get_style_priority(),
				);
				ET_Builder_Element::set_style( $function_name, wp_parse_args( $background_args, $el_style ) );
			}

			// Render pattern styles.
			if ( &#039;&#039; !== $style_pattern ) {
				$el_pattern_style = array(
					&#039;selector&#039;    =&gt; $selector_pattern,
					&#039;declaration&#039; =&gt; rtrim( $style_pattern ),
					&#039;priority&#039;    =&gt; $module-&gt;get_style_priority(),
				);
				ET_Builder_Element::set_style( $function_name, wp_parse_args( $background_args, $el_pattern_style ) );
			}

			// Render mask styles.
			if ( &#039;&#039; !== $style_mask ) {
				$el_mask_style = array(
					&#039;selector&#039;    =&gt; $selector_mask,
					&#039;declaration&#039; =&gt; rtrim( $style_mask ),
					&#039;priority&#039;    =&gt; $module-&gt;get_style_priority(),
				);
				ET_Builder_Element::set_style( $function_name, wp_parse_args( $background_args, $el_mask_style ) );
			}
		}

		// Background Modes (Hover &amp; Sticky).
		$modes = array( &#039;hover&#039;, &#039;sticky&#039; );

		foreach ( $modes as $mode ) {
			// Get helper.
			$helper = et_builder_get_helper( $mode );

			// Bail if no helper.
			if ( ! $helper ) {
				continue;
			}

			// Get selector.
			$selector_mode = $args[ &quot;selector_{$mode}&quot; ];

			$selector_pattern_mode = &#039;&#039;;
			$selector_mask_mode    = &#039;&#039;;

			// If no fixed selector defined, prepend / append default selector.
			if ( &#039;&#039; === $selector_mode ) {
				if ( &#039;hover&#039; === $mode ) {
					$selector_mode = $helper-&gt;add_hover_to_selectors( $selector );
				} elseif ( &#039;sticky&#039; === $mode ) {
					$is_sticky_module = $helper-&gt;is_sticky_module( $props );
					$selector_mode    = $helper-&gt;add_sticky_to_order_class( $selector, $is_sticky_module );
				}
			}

			$base_prop_name_mode_parsed = $this-&gt;get_prop_name_alias( $prop_name_aliases, $base_prop_name );
			$is_enabled_mode            = $helper-&gt;is_enabled( $base_prop_name_mode_parsed, $props );
			$background_image_field     = &quot;{$base_prop_name}_image&quot;;

			if ( &#039;hover&#039; === $mode ) {
				$selector_pattern_mode  = $helper-&gt;add_hover_to_order_class( $selector_pattern );
				$selector_mask_mode     = $helper-&gt;add_hover_to_order_class( $selector_mask );
				$background_image_field = $helper-&gt;get_hover_field( $background_image_field );
			} elseif ( &#039;sticky&#039; === $mode ) {
				$is_sticky_module       = $helper-&gt;is_sticky_module( $props );
				$selector_pattern_mode  = $helper-&gt;add_sticky_to_order_class( $selector_pattern, $is_sticky_module );
				$selector_mask_mode     = $helper-&gt;add_sticky_to_order_class( $selector_mask, $is_sticky_module );
				$background_image_field = $helper-&gt;get_sticky_field( $background_image_field );
			}

			// Check if mode is enabled.
			if ( $is_enabled_mode ) {
				$images_mode = array();
				$style_mode  = &#039;&#039;;

				$style_pattern_mode = &#039;&#039;;
				$style_mask_mode    = &#039;&#039;;

				$has_gradient_mode           = false;
				$has_image_mode              = false;
				$has_gradient_and_image_mode = false;
				$is_gradient_mode_disabled   = false;
				$is_image_mode_disabled      = false;

				$gradient_overlays_image_mode = &#039;off&#039;;

				// Background Gradient Mode (Hover / Sticky).
				// This part is little bit different compared to responsive implementation. In
				// this case, mode is enabled on the background field, not on the each of those
				// fields. So, built in function get_value() doesn&#039;t work in this case.
				// Temporarily, we need to fetch the the value from get_raw_value().
				if ( $use_gradient_options &amp;&amp; &#039;fields_only&#039; !== $use_gradient_options ) {
					$use_gradient_mode = $responsive-&gt;get_inheritance_background_value(
						$props,
						$this-&gt;get_prop_name_alias( $prop_name_aliases, &quot;use_{$base_prop_name}_color_gradient&quot; ),
						$mode,
						$base_prop_name,
						$fields_definition
					);

					// 1. Ensure gradient color is active and values are not null.
					if ( &#039;on&#039; === $use_gradient_mode ) {
						// Flag to inform BG Color if current module has Gradient.
						$has_gradient_mode    = true;
						$gradient_values_mode = $this-&gt;get_gradient_mode_properties(
							$mode,
							$props,
							$base_prop_name,
							$gradient_properties_desktop
						);

						$gradient_mode = $this-&gt;get_gradient_style( $gradient_values_mode );
						$images_mode[] = $gradient_mode;

						$gradient_overlays_image_desktop = $responsive-&gt;get_any_value(
							$props,
							&quot;{$base_prop_name}_color_gradient_overlays_image&quot;,
							&#039;&#039;,
							true
						);
						$gradient_overlays_image_mode    = $helper-&gt;get_raw_value(
							&quot;{$base_prop_name}_color_gradient_overlays_image&quot;,
							$props,
							$gradient_overlays_image_desktop
						);
					} elseif ( &#039;off&#039; === $use_gradient_mode ) {
						$is_gradient_mode_disabled = true;
					}
				}

				// Background Image Mode (Hover / Sticky).
				// This part is little bit different compared to responsive implementation. In
				// this case, mode is enabled on the background field, not on the each of those
				// fields. So, built in function get_value() doesn&#039;t work in this case.
				// Temporarily, we need to fetch the the value from get_raw_value().
				if ( $use_image_options &amp;&amp; &#039;fields_only&#039; !== $use_image_options ) {
					$image_mode    = $responsive-&gt;get_inheritance_background_value(
						$props,
						&quot;{$base_prop_name}_image&quot;,
						$mode,
						$base_prop_name,
						$fields_definition
					);
					$parallax_mode = $helper-&gt;get_raw_value( &#039;parallax&#039;, $props );

					// Determine whether force inline styles.
					if ( ! ET_Builder_Element::$forced_inline_styles ) {
						$raw = isset( $attrs_unprocessed[ $background_image_field ] ) ? $attrs_unprocessed[ $background_image_field ] : &#039;&#039;;
						if ( $this-&gt;_is_dynamic_value( $background_image_field, $raw, $dynamic_attributes ) ) {
							ET_Builder_Element::$forced_inline_styles = true;
						}
					}

					// Featured image as background is in higher priority.
					if ( $module-&gt;featured_image_background ) {
						$featured_image         = isset( $props[&#039;featured_image&#039;] ) ? $props[&#039;featured_image&#039;] : &#039;&#039;;
						$featured_placement     = isset( $props[&#039;featured_placement&#039;] ) ? $props[&#039;featured_placement&#039;] : &#039;&#039;;
						$featured_image_src_obj = wp_get_attachment_image_src( get_post_thumbnail_id( self::_get_main_post_id() ), &#039;full&#039; );
						$featured_image_src     = isset( $featured_image_src_obj[0] ) ? $featured_image_src_obj[0] : &#039;&#039;;

						if ( &#039;on&#039; === $featured_image &amp;&amp; &#039;background&#039; === $featured_placement &amp;&amp; &#039;&#039; !== $featured_image_src ) {
							$image_mode = $featured_image_src;
						}
					}

					if ( &#039;&#039; !== $image_mode &amp;&amp; null !== $image_mode &amp;&amp; &#039;on&#039; !== $parallax_mode ) {
						// Flag to inform BG Color if current module has Image.
						$has_image_mode = true;

						// Size.
						$image_size_default = $this-&gt;get_attr_default( &#039;size&#039;, $base_prop_name, $fields_definition );
						$image_size_mode    = $helper-&gt;get_raw_value( &quot;{$base_prop_name}_size&quot;, $props );
						$image_size_desktop = isset( $props[ &quot;{$base_prop_name}_size&quot; ] ) ? $props[ &quot;{$base_prop_name}_size&quot; ] : &#039;&#039;;

						if ( empty( $image_size_mode ) &amp;&amp; ! empty( $image_size_desktop ) ) {
							$image_size_mode = $image_size_desktop;
						}

						$is_same_image_size = $image_size_mode === $image_size_desktop;

						if ( ! empty( $image_size_mode ) &amp;&amp; ! $is_same_image_size ) {
							$image_width_desktop  = isset( $props[ &quot;{$base_prop_name}_image_width&quot; ] ) ? $props[ &quot;{$base_prop_name}_image_width&quot; ] : &#039;&#039;;
							$image_width_mode     = $helper-&gt;get_raw_value( &quot;{$base_prop_name}_image_width&quot;, $props, $image_width_desktop );
							$image_height_desktop = isset( $props[ &quot;{$base_prop_name}_image_height&quot; ] ) ? $props[ &quot;{$base_prop_name}_image_height&quot; ] : &#039;&#039;;
							$image_height_mode    = $helper-&gt;get_raw_value( &quot;{$base_prop_name}_image_height&quot;, $props, $image_height_desktop );

							// Get Size CSS.
							$image_size_style_desktop = $this-&gt;get_background_size_css( $image_size_desktop, $image_width_desktop, $image_height_desktop, $image_size_default, &#039;image&#039; );
							$image_size_style_mode    = $this-&gt;get_background_size_css( $image_size_mode, $image_width_mode, $image_height_mode, $image_size_default, &#039;image&#039; );

							$is_same_image_size_style = $image_size_style_mode === $image_size_style_desktop;

							if ( ! empty( $image_size_style_mode ) &amp;&amp; ! $is_same_image_size_style ) {
								if ( isset( $image_size_style_mode[&#039;size&#039;] ) &amp;&amp; $image_size_style_mode[&#039;size&#039;] ) {
									$style_mode .= sprintf(
										&#039;background-size: %1$s; &#039;,
										esc_html( $image_size_style_mode[&#039;size&#039;] )
									);
								}
							}
						}

						// Check if image size has &#039;stretch&#039; value or not.
						$is_image_size_stretch_mode = &#039;stretch&#039; === $image_size_mode;

						// Repeat.
						$image_repeat_mode    = $helper-&gt;get_raw_value( &quot;{$base_prop_name}_repeat&quot;, $props );
						$image_repeat_desktop = isset( $props[ &quot;{$base_prop_name}_repeat&quot; ] ) ? $props[ &quot;{$base_prop_name}_repeat&quot; ] : &#039;&#039;;
						$is_same_image_repeat = $image_repeat_mode === $image_repeat_desktop;

						if ( empty( $image_repeat_mode ) &amp;&amp; ! empty( $image_repeat_desktop ) ) {
							$image_repeat_mode = $image_repeat_desktop;
						}

						// Don&#039;t print the same image repeat.
						// Don&#039;t print image repeat when image size is &#039;stretch&#039;.
						if ( ! empty( $image_repeat_mode ) &amp;&amp; ! $is_same_image_repeat &amp;&amp; ! $is_image_size_stretch_mode ) {
							$style_mode .= sprintf(
								&#039;background-repeat: %1$s; &#039;,
								esc_html( $image_repeat_mode )
							);
						}

						// Position.
						$image_position_mode    = $helper-&gt;get_raw_value( &quot;{$base_prop_name}_position&quot;, $props );
						$image_position_desktop = isset( $props[ &quot;{$base_prop_name}_position&quot; ] ) ? $props[ &quot;{$base_prop_name}_position&quot; ] : &#039;&#039;;

						if ( empty( $image_position_mode ) &amp;&amp; ! empty( $image_position_desktop ) ) {
							$image_position_mode = $image_position_desktop;
						}

						// Check if pattern repeat has &#039;space&#039; value or not.
						$is_image_repeat_space_mode = &#039;space&#039; === $image_repeat_mode;

						// Print image position/offset when pattern size is not &#039;stretch&#039;, and
						// image repeat is not &#039;space&#039;.
						if ( ! empty( $image_position_mode ) &amp;&amp; ! $is_image_repeat_space_mode &amp;&amp; ! $is_image_size_stretch_mode ) {
							$horizontal_offset_desktop = isset( $props[ &quot;{$base_prop_name}_horizontal_offset&quot; ] ) ? $props[ &quot;{$base_prop_name}_horizontal_offset&quot; ] : &#039;&#039;;
							$horizontal_offset_mode    = $helper-&gt;get_raw_value( &quot;{$base_prop_name}_horizontal_offset&quot;, $props, $horizontal_offset_desktop );
							$vertical_offset_desktop   = isset( $props[ &quot;{$base_prop_name}_vertical_offset&quot; ] ) ? $props[ &quot;{$base_prop_name}_vertical_offset&quot; ] : &#039;&#039;;
							$vertical_offset_mode      = $helper-&gt;get_raw_value( &quot;{$base_prop_name}_vertical_offset&quot;, $props, $vertical_offset_desktop );

							// Get Position CSS.
							$image_position_style_desktop = $this-&gt;get_background_position_css( $image_position_desktop, $horizontal_offset_desktop, $vertical_offset_desktop );
							$image_position_style_mode    = $this-&gt;get_background_position_css( $image_position_mode, $horizontal_offset_mode, $vertical_offset_mode );

							$is_same_image_position_style = $image_position_style_mode === $image_position_style_desktop;

							if ( ! empty( $image_position_style_mode ) &amp;&amp; ! $is_same_image_position_style ) {
								$style_mode .= sprintf(
									&#039;background-position: %1$s; &#039;,
									esc_html( $image_position_style_mode[&#039;position&#039;] )
								);
							}
						}

						// Blend.
						$image_blend_mode    = $helper-&gt;get_raw_value( &quot;{$base_prop_name}_blend&quot;, $props );
						$image_blend_default = $this-&gt;get_attr_default( &#039;blend&#039;, $base_prop_name, $fields_definition );
						$image_blend_desktop = isset( $props[ &quot;{$base_prop_name}_blend&quot; ] ) ? $props[ &quot;{$base_prop_name}_blend&quot; ] : &#039;&#039;;
						$is_same_image_blend = $image_blend_mode === $image_blend_desktop;

						if ( empty( $image_blend_mode ) &amp;&amp; ! empty( $image_blend_desktop ) ) {
							$image_blend_mode = $image_blend_desktop;
						}

						if ( ! empty( $image_blend_mode ) ) {
							// Don&#039;t print the same background blend.
							if ( ! $is_same_image_blend ) {
								$style_mode .= sprintf(
									&#039;background-blend-mode: %1$s; &#039;,
									esc_html( $image_blend_mode )
								);
							}

							// Force background-color: initial.
							if ( $has_gradient_mode &amp;&amp; $has_image_mode &amp;&amp; $image_blend_mode !== $image_blend_default ) {
								$has_gradient_and_image_mode = true;
								$style_mode                 .= sprintf( &#039;background-color: initial%1$s; &#039;, esc_html( $important ) );
							}
						}

						// Only append background image when the image is exist.
						$images_mode[] = sprintf( &#039;url(%1$s)&#039;, esc_html( $image_mode ) );
					} elseif ( &#039;&#039; === $image_mode ) {
						$is_image_mode_disabled = true;
					}
				}

				if ( ! empty( $images_mode ) ) {
					// Check if Parallax and Gradient Overlays are on.
					$gradient_overlays_image_desktop = $responsive-&gt;get_any_value( $props, &quot;{$base_prop_name}_color_gradient_overlays_image&quot;, &#039;off&#039;, true );
					$gradient_overlays_image_mode    = $helper-&gt;get_raw_value( &quot;{$base_prop_name}_color_gradient_overlays_image&quot;, $props, $gradient_overlays_image_desktop );
					$parallax_desktop                = $responsive-&gt;get_any_value( $props, &#039;parallax&#039;, &#039;off&#039;, true );
					$parallax_mode                   = $helper-&gt;get_raw_value( &#039;parallax&#039;, $props, $parallax_desktop );

					// The browsers stack the images in the opposite order to what you&#039;d expect.
					if ( &#039;on&#039; !== $gradient_overlays_image_mode ) {
						$images_mode = array_reverse( $images_mode );
					}

					if ( $use_gradient_options &amp;&amp; &#039;on&#039; === $gradient_overlays_image_mode &amp;&amp; &#039;on&#039; === $parallax_mode ) {
						// Set background image to initial when Parallax and Gradient Overlays are on.
						$images_mode = &#039;initial&#039;;
					} else {
						$images_mode = join( &#039;, &#039;, $images_mode );
					}

					$style_mode .= sprintf(
						&#039;background-image: %1$s%2$s;&#039;,
						esc_html( $images_mode ),
						$important
					);
				} elseif ( $is_gradient_mode_disabled &amp;&amp; $is_image_mode_disabled ) {
					$style_mode .= sprintf(
						&#039;background-image: initial %1$s;&#039;,
						$important
					);
				}

				// Background Color Mode (Hover / Sticky).
				if ( $use_color_options &amp;&amp; &#039;fields_only&#039; !== $use_color_options ) {
					$use_color_mode_default = isset( $props[ &quot;use_{$base_prop_name}_color&quot; ] ) ? $props[ &quot;use_{$base_prop_name}_color&quot; ] : &#039;on&#039;;
					$use_color_mode_value   = $helper-&gt;get_raw_value( &quot;use_{$base_prop_name}_color&quot;, $props );
					$use_color_mode_value   = ! empty( $use_color_mode_value )
						? $use_color_mode_value
						: $use_color_mode_default;

					if ( ! $has_gradient_and_image_mode &amp;&amp; &#039;off&#039; !== $use_color_mode_value ) {
						$color_mode = $responsive-&gt;get_inheritance_background_value(
							$props,
							&quot;{$base_prop_name}_color&quot;,
							$mode,
							$base_prop_name,
							$fields_definition
						);

						$color_mode = &#039;&#039; !== $color_mode ? $color_mode : &#039;transparent&#039;;

						if ( &#039;&#039; !== $color_mode ) {
							$style_mode .= sprintf(
								&#039;background-color: %1$s%2$s; &#039;,
								esc_html( $this-&gt;get_color_value( $color_mode ) ),
								esc_html( $important )
							);
						}
					} elseif ( $has_color_toggle_options &amp;&amp; &#039;off&#039; === $use_color_mode_value ) {
						// Reset - If current module has background color toggle, it&#039;s off, and current mode
						// it&#039;s not desktop, we should reset the background color.
						$style .= sprintf(
							&#039;background-color: initial %1$s; &#039;,
							esc_html( $important )
						);
					}
				}

				// Background Pattern Mode (Hover / Sticky).
				// This part is little bit different compared to responsive implementation. In
				// this case, mode is enabled on the background field, not on the each of those
				// fields. So, built in function get_value() doesn&#039;t work in this case.
				// Temporarily, we need to fetch the the value from get_raw_value().
				if ( $use_pattern_options &amp;&amp; &#039;fields_only&#039; !== $use_pattern_options ) {
					$pattern_style_name_mode = $responsive-&gt;get_inheritance_background_value(
						$props,
						&quot;{$pattern_base_prop_name}_style&quot;,
						$mode,
						$base_prop_name,
						$fields_definition
					);

					if ( &#039;&#039; !== $pattern_style_name_mode ) {
						// Pattern Transform.
						$pattern_transform_mode    = $helper-&gt;get_raw_value( &quot;{$pattern_base_prop_name}_transform&quot;, $props );
						$pattern_transform_desktop = isset( $props[ &quot;{$pattern_base_prop_name}_transform&quot; ] ) ? $props[ &quot;{$pattern_base_prop_name}_transform&quot; ] : &#039;&#039;;

						if ( empty( $pattern_transform_mode ) &amp;&amp; ! empty( $pattern_transform_desktop ) ) {
							$pattern_transform_mode = $pattern_transform_desktop;
						}

						$pattern_is_horizontal_mode = $this-&gt;get_transform_state( $pattern_transform_mode, &#039;horizontal&#039; );
						$pattern_is_vertical_mode   = $this-&gt;get_transform_state( $pattern_transform_mode, &#039;vertical&#039; );
						$pattern_is_rotated_mode    = $this-&gt;get_transform_state( $pattern_transform_mode, &#039;rotate&#039; );
						$pattern_is_inverted_mode   = $this-&gt;get_transform_state( $pattern_transform_mode, &#039;invert&#039; );

						if ( ! empty( $pattern_transform_mode ) &amp;&amp; ( $pattern_is_horizontal_mode || $pattern_is_vertical_mode ) ) {
							$style_pattern_mode .= sprintf(
								&#039;transform: %1$s; &#039;,
								esc_html( $this-&gt;get_transform_css( $pattern_is_horizontal_mode, $pattern_is_vertical_mode ) )
							);
						};

						// Set background pattern style only it&#039;s different compared to the larger device.
						$pattern_color_mode    = $helper-&gt;get_raw_value( &quot;{$pattern_base_prop_name}_color&quot;, $props );
						$pattern_color_desktop = isset( $props[ &quot;{$pattern_base_prop_name}_color&quot; ] ) ? $props[ &quot;{$pattern_base_prop_name}_color&quot; ] : &#039;&#039;;

						if ( empty( $pattern_color_mode ) &amp;&amp; ! empty( $pattern_color_desktop ) ) {
							$pattern_color_mode = $pattern_color_desktop;
						}

						$pattern_style_svg_mode = et_pb_background_pattern_options()-&gt;get_svg( $pattern_style_name_mode, $pattern_color_mode, &#039;default&#039;, $pattern_is_rotated_mode, $pattern_is_inverted_mode );

						$style_pattern_mode .= sprintf(
							&#039;background-image: %1$s; &#039;,
							esc_html( $pattern_style_svg_mode )
						);

						// Pattern Size.
						$pattern_size_mode    = $helper-&gt;get_raw_value( &quot;{$pattern_base_prop_name}_size&quot;, $props );
						$pattern_size_desktop = isset( $props[ &quot;{$pattern_base_prop_name}_size&quot; ] ) ? $props[ &quot;{$pattern_base_prop_name}_size&quot; ] : &#039;&#039;;

						if ( empty( $pattern_size_mode ) &amp;&amp; ! empty( $pattern_size_desktop ) ) {
							$pattern_size_mode = $pattern_size_desktop;
						}

						if ( ! empty( $pattern_size_mode ) ) {
							$pattern_width_desktop  = isset( $props[ &quot;{$pattern_base_prop_name}_width&quot; ] ) ? $props[ &quot;{$pattern_base_prop_name}_width&quot; ] : &#039;&#039;;
							$pattern_width_mode     = $helper-&gt;get_raw_value( &quot;{$pattern_base_prop_name}_width&quot;, $props, $pattern_width_desktop );
							$pattern_height_desktop = isset( $props[ &quot;{$pattern_base_prop_name}_height&quot; ] ) ? $props[ &quot;{$pattern_base_prop_name}_height&quot; ] : &#039;&#039;;
							$pattern_height_mode    = $helper-&gt;get_raw_value( &quot;{$pattern_base_prop_name}_height&quot;, $props, $pattern_height_desktop );

							// Get Size CSS.
							$pattern_size_style_desktop = $this-&gt;get_background_size_css( $pattern_size_desktop, $pattern_width_desktop, $pattern_height_desktop );
							$pattern_size_style_mode    = $this-&gt;get_background_size_css( $pattern_size_mode, $pattern_width_mode, $pattern_height_mode );

							$is_same_pattern_size_style = $pattern_size_style_mode === $pattern_size_style_desktop;

							if ( ! empty( $pattern_size_style_mode ) &amp;&amp; ! $is_same_pattern_size_style ) {
								if ( isset( $pattern_size_style_mode[&#039;size&#039;] ) &amp;&amp; $pattern_size_style_mode[&#039;size&#039;] ) {
									$style_pattern_mode .= sprintf(
										&#039;background-size: %1$s; &#039;,
										esc_html( $pattern_size_style_mode[&#039;size&#039;] )
									);
								}
							}
						}

						// Check if pattern size has &#039;stretch&#039; value or not.
						$is_pattern_size_stretch_mode = &#039;stretch&#039; === $pattern_size_mode;

						// Pattern Repeat.
						$pattern_repeat_mode    = $helper-&gt;get_raw_value( &quot;{$pattern_base_prop_name}_repeat&quot;, $props );
						$pattern_repeat_desktop = isset( $props[ &quot;{$pattern_base_prop_name}_repeat&quot; ] ) ? $props[ &quot;{$pattern_base_prop_name}_repeat&quot; ] : &#039;&#039;;

						if ( empty( $pattern_repeat_mode ) &amp;&amp; ! empty( $pattern_repeat_desktop ) ) {
							$pattern_repeat_mode = $pattern_repeat_desktop;
						}

						$is_same_pattern_repeat_style = $pattern_repeat_mode === $pattern_repeat_desktop;

						// Don&#039;t print the same pattern repeat.
						// Don&#039;t print pattern repeat when pattern size is &#039;stretch&#039;.
						if ( ! empty( $pattern_repeat_mode ) &amp;&amp; ! $is_same_pattern_repeat_style &amp;&amp; ! $is_pattern_size_stretch_mode ) {
							$style_pattern_mode .= sprintf(
								&#039;background-repeat: %1$s; &#039;,
								esc_html( $pattern_repeat_mode )
							);
						}

						// Pattern repeat origin.
						$pattern_position_mode    = $helper-&gt;get_raw_value( &quot;{$pattern_base_prop_name}_repeat_origin&quot;, $props );
						$pattern_position_desktop = isset( $props[ &quot;{$pattern_base_prop_name}_repeat_origin&quot; ] ) ? $props[ &quot;{$pattern_base_prop_name}_repeat_origin&quot; ] : &#039;&#039;;

						if ( empty( $pattern_position_mode ) &amp;&amp; ! empty( $pattern_position_desktop ) ) {
							$pattern_position_mode = $pattern_position_desktop;
						}

						// Check if pattern repeat has &#039;space&#039; value or not.
						$is_pattern_repeat_space_mode = &#039;space&#039; === $pattern_repeat_mode;

						// Print pattern repeat origin/offset when pattern size is not &#039;stretch&#039;,
						// and pattern repeat is not &#039;space&#039;.
						if ( ! empty( $pattern_position_mode ) &amp;&amp; ! $is_pattern_repeat_space_mode &amp;&amp; ! $is_pattern_size_stretch_mode ) {
							$pattern_horizontal_offset_desktop = isset( $props[ &quot;{$pattern_base_prop_name}_horizontal_offset&quot; ] ) ? $props[ &quot;{$pattern_base_prop_name}_horizontal_offset&quot; ] : &#039;&#039;;
							$pattern_horizontal_offset_mode    = $helper-&gt;get_raw_value( &quot;{$pattern_base_prop_name}_horizontal_offset&quot;, $props, $pattern_horizontal_offset_desktop );
							$pattern_vertical_offset_desktop   = isset( $props[ &quot;{$pattern_base_prop_name}_vertical_offset&quot; ] ) ? $props[ &quot;{$pattern_base_prop_name}_vertical_offset&quot; ] : &#039;&#039;;
							$pattern_vertical_offset_mode      = $helper-&gt;get_raw_value( &quot;{$pattern_base_prop_name}_vertical_offset&quot;, $props, $pattern_vertical_offset_desktop );

							// Get Position CSS.
							$pattern_position_style_desktop = $this-&gt;get_background_position_css( $pattern_position_desktop, $pattern_horizontal_offset_desktop, $pattern_vertical_offset_desktop );
							$pattern_position_style_mode    = $this-&gt;get_background_position_css( $pattern_position_mode, $pattern_horizontal_offset_mode, $pattern_vertical_offset_mode );

							$is_same_pattern_position_style = $pattern_position_style_mode === $pattern_position_style_desktop;

							if ( ! empty( $pattern_position_style_mode ) &amp;&amp; ! $is_same_pattern_position_style ) {
								$style_pattern_mode .= sprintf(
									&#039;background-position: %1$s; &#039;,
									esc_html( $pattern_position_style_mode[&#039;position&#039;] )
								);
							}
						}

						// Pattern Blend Mode.
						$pattern_blend_mode    = $helper-&gt;get_raw_value( &quot;{$pattern_base_prop_name}_blend_mode&quot;, $props );
						$pattern_blend_desktop = isset( $props[ &quot;{$pattern_base_prop_name}_blend_mode&quot; ] ) ? $props[ &quot;{$pattern_base_prop_name}_blend_mode&quot; ] : &#039;&#039;;

						if ( empty( $pattern_blend_mode ) &amp;&amp; ! empty( $pattern_blend_desktop ) ) {
							$pattern_blend_mode = $pattern_blend_desktop;
						}

						$is_same_pattern_blend_style = $pattern_blend_mode === $pattern_blend_desktop;

						// Don&#039;t print the same pattern blend mode.
						if ( ! empty( $pattern_blend_mode ) &amp;&amp; ! $is_same_pattern_blend_style ) {
							$style_pattern_mode .= sprintf(
								&#039;mix-blend-mode: %1$s; &#039;,
								esc_html( $pattern_blend_mode )
							);
						}
					}
				}

				// Background Mask Mode (Hover / Sticky).
				// This part is little bit different compared to responsive implementation. In
				// this case, mode is enabled on the background field, not on the each of those
				// fields. So, built in function get_value() doesn&#039;t work in this case.
				// Temporarily, we need to fetch the the value from get_raw_value().
				if ( $use_mask_options &amp;&amp; &#039;fields_only&#039; !== $use_mask_options ) {
					$mask_style_name_mode = $responsive-&gt;get_inheritance_background_value(
						$props,
						&quot;{$base_prop_name}_mask_style&quot;,
						$mode,
						$base_prop_name,
						$fields_definition
					);

					if ( &#039;&#039; !== $mask_style_name_mode ) {
						// Mask Transform.
						$mask_transform_mode    = $helper-&gt;get_raw_value( &quot;{$mask_base_prop_name}_transform&quot;, $props );
						$mask_transform_desktop = isset( $props[ &quot;{$mask_base_prop_name}_transform&quot; ] ) ? $props[ &quot;{$mask_base_prop_name}_transform&quot; ] : &#039;&#039;;

						if ( empty( $mask_transform_mode ) &amp;&amp; ! empty( $mask_transform_desktop ) ) {
							$mask_transform_mode = $mask_transform_desktop;
						}

						$mask_is_horizontal_mode = $this-&gt;get_transform_state( $mask_transform_mode, &#039;horizontal&#039; );
						$mask_is_vertical_mode   = $this-&gt;get_transform_state( $mask_transform_mode, &#039;vertical&#039; );
						$mask_is_rotated_mode    = $this-&gt;get_transform_state( $mask_transform_mode, &#039;rotate&#039; );
						$mask_is_inverted_mode   = $this-&gt;get_transform_state( $mask_transform_mode, &#039;invert&#039; );

						if ( ! empty( $mask_transform_mode ) &amp;&amp; ( $mask_is_horizontal_mode || $mask_is_vertical_mode ) ) {
							$style_mask_mode .= sprintf(
								&#039;transform: %1$s; &#039;,
								esc_html( $this-&gt;get_transform_css( $mask_is_horizontal_mode, $mask_is_vertical_mode ) )
							);
						};

						// Mask Size.
						$mask_size_default = $this-&gt;get_attr_default( &#039;size&#039;, $mask_base_prop_name, $fields_definition );
						$mask_size_mode    = $helper-&gt;get_raw_value( &quot;{$mask_base_prop_name}_size&quot;, $props );
						$mask_size_desktop = isset( $props[ &quot;{$mask_base_prop_name}_size&quot; ] ) ? $props[ &quot;{$mask_base_prop_name}_size&quot; ] : &#039;&#039;;

						if ( empty( $mask_size_mode ) &amp;&amp; ! empty( $mask_size_desktop ) ) {
							$mask_size_mode = $mask_size_desktop;
						}

						if ( ! empty( $mask_size_mode ) ) {
							$mask_width_desktop  = isset( $props[ &quot;{$mask_base_prop_name}_width&quot; ] ) ? $props[ &quot;{$mask_base_prop_name}_width&quot; ] : &#039;&#039;;
							$mask_width_mode     = $helper-&gt;get_raw_value( &quot;{$mask_base_prop_name}_width&quot;, $props, $mask_width_desktop );
							$mask_height_desktop = isset( $props[ &quot;{$mask_base_prop_name}_height&quot; ] ) ? $props[ &quot;{$mask_base_prop_name}_height&quot; ] : &#039;&#039;;
							$mask_height_mode    = $helper-&gt;get_raw_value( &quot;{$mask_base_prop_name}_height&quot;, $props, $mask_height_desktop );

							// Get Size CSS.
							$mask_size_style_desktop = $this-&gt;get_background_size_css( $mask_size_desktop, $mask_width_desktop, $mask_height_desktop, $mask_size_default, &#039;mask&#039; );
							$mask_size_style_mode    = $this-&gt;get_background_size_css( $mask_size_mode, $mask_width_mode, $mask_height_mode, $mask_size_default, &#039;mask&#039; );

							$is_same_mask_size_style = $mask_size_style_mode === $mask_size_style_desktop;

							if ( ! empty( $mask_size_style_mode ) &amp;&amp; ! $is_same_mask_size_style ) {
								if ( isset( $mask_size_style_mode[&#039;size&#039;] ) &amp;&amp; $mask_size_style_mode[&#039;size&#039;] ) {
									$style_mask_mode .= sprintf(
										&#039;background-size: %1$s; &#039;,
										esc_html( $mask_size_style_mode[&#039;size&#039;] )
									);
								}
							}
						}

						// Set background mask style only it&#039;s different compared to the larger device.
						$mask_color_mode    = $helper-&gt;get_raw_value( &quot;{$mask_base_prop_name}_color&quot;, $props );
						$mask_color_desktop = isset( $props[ &quot;{$mask_base_prop_name}_color&quot; ] ) ? $props[ &quot;{$mask_base_prop_name}_color&quot; ] : &#039;&#039;;

						if ( empty( $mask_color_mode ) &amp;&amp; ! empty( $mask_color_desktop ) ) {
							$mask_color_mode = $mask_color_desktop;
						}

						$mask_ratio_mode    = $helper-&gt;get_raw_value( &quot;{$mask_base_prop_name}_aspect_ratio&quot;, $props );
						$mask_ratio_desktop = isset( $props[ &quot;{$mask_base_prop_name}_aspect_ratio&quot; ] ) ? $props[ &quot;{$mask_base_prop_name}_aspect_ratio&quot; ] : &#039;&#039;;

						if ( empty( $mask_ratio_mode ) &amp;&amp; ! empty( $mask_ratio_desktop ) ) {
							$mask_ratio_mode = $mask_ratio_desktop;
						}

						$mask_style_svg_mode = et_pb_background_mask_options()-&gt;get_svg( $mask_style_name_mode, $mask_color_mode, $mask_ratio_mode, $mask_is_rotated_mode, $mask_is_inverted_mode, $mask_size_mode );

						$style_mask_mode .= sprintf(
							&#039;background-image: %1$s; &#039;,
							esc_html( $mask_style_svg_mode )
						);

						// Mask Position.
						$mask_position_mode    = $helper-&gt;get_raw_value( &quot;{$mask_base_prop_name}_position&quot;, $props );
						$mask_position_desktop = isset( $props[ &quot;{$mask_base_prop_name}_position&quot; ] ) ? $props[ &quot;{$mask_base_prop_name}_position&quot; ] : &#039;&#039;;

						if ( empty( $mask_position_mode ) &amp;&amp; ! empty( $mask_position_desktop ) ) {
							$mask_position_mode = $mask_position_desktop;
						}

						if ( ! empty( $mask_position_mode ) &amp;&amp; ! empty( $mask_size_mode ) &amp;&amp; &#039;stretch&#039; !== $mask_size_mode ) {
							$mask_horizontal_offset_desktop = isset( $props[ &quot;{$mask_base_prop_name}_horizontal_offset&quot; ] ) ? $props[ &quot;{$mask_base_prop_name}_horizontal_offset&quot; ] : &#039;&#039;;
							$mask_horizontal_offset_mode    = $helper-&gt;get_raw_value( &quot;{$mask_base_prop_name}_horizontal_offset&quot;, $props, $mask_horizontal_offset_desktop );
							$mask_vertical_offset_desktop   = isset( $props[ &quot;{$mask_base_prop_name}_vertical_offset&quot; ] ) ? $props[ &quot;{$mask_base_prop_name}_vertical_offset&quot; ] : &#039;&#039;;
							$mask_vertical_offset_mode      = $helper-&gt;get_raw_value( &quot;{$mask_base_prop_name}_vertical_offset&quot;, $props, $mask_vertical_offset_desktop );

							// Get Position CSS.
							$mask_position_style_desktop = $this-&gt;get_background_position_css( $mask_position_desktop, $mask_horizontal_offset_desktop, $mask_vertical_offset_desktop );
							$mask_position_style_mode    = $this-&gt;get_background_position_css( $mask_position_mode, $mask_horizontal_offset_mode, $mask_vertical_offset_mode );

							$is_same_mask_position_style = $mask_position_style_mode === $mask_position_style_desktop;

							if ( ! empty( $mask_position_style_mode ) &amp;&amp; ! $is_same_mask_position_style ) {
								$style_mask_mode .= sprintf(
									&#039;background-position: %1$s; &#039;,
									esc_html( $mask_position_style_mode[&#039;position&#039;] )
								);
							}
						}

						// Mask Blend Mode.
						$mask_blend_mode    = $helper-&gt;get_raw_value( &quot;{$mask_base_prop_name}_blend_mode&quot;, $props );
						$mask_blend_desktop = isset( $props[ &quot;{$mask_base_prop_name}_blend_mode&quot; ] ) ? $props[ &quot;{$mask_base_prop_name}_blend_mode&quot; ] : &#039;&#039;;

						if ( empty( $mask_blend_mode ) &amp;&amp; ! empty( $mask_blend_desktop ) ) {
							$mask_blend_mode = $mask_blend_desktop;
						}

						$is_same_mask_blend_style = $mask_blend_mode === $mask_blend_desktop;

						// Don&#039;t print the same mask blend mode.
						if ( ! empty( $mask_blend_mode ) &amp;&amp; ! $is_same_mask_blend_style ) {
							$style_mask_mode .= sprintf(
								&#039;mix-blend-mode: %1$s; &#039;,
								esc_html( $mask_blend_mode )
							);
						}
					}
				}

				// Render background mode styles.
				if ( &#039;&#039; !== $style_mode ) {
					$el_style = array(
						&#039;selector&#039;    =&gt; $selector_mode,
						&#039;declaration&#039; =&gt; rtrim( $style_mode ),
						&#039;priority&#039;    =&gt; $module-&gt;get_style_priority(),
					);
					ET_Builder_Element::set_style( $function_name, $el_style );
				}

				// Render pattern mode styles.
				if ( &#039;&#039; !== $style_pattern_mode ) {
					$el_pattern_style = array(
						&#039;selector&#039;    =&gt; $selector_pattern_mode,
						&#039;declaration&#039; =&gt; rtrim( $style_pattern_mode ),
						&#039;priority&#039;    =&gt; $module-&gt;get_style_priority(),
					);
					ET_Builder_Element::set_style( $function_name, $el_pattern_style );
				}

				// Render mask mode styles.
				if ( &#039;&#039; !== $style_mask_mode ) {
					$el_mask_style = array(
						&#039;selector&#039;    =&gt; $selector_mask_mode,
						&#039;declaration&#039; =&gt; rtrim( $style_mask_mode ),
						&#039;priority&#039;    =&gt; $module-&gt;get_style_priority(),
					);
					ET_Builder_Element::set_style( $function_name, $el_mask_style );
				}
			}
		}

		// Cleanup.
		$args              = null;
		$attrs_unprocessed = null;
		$feature_manager   = null;
		$module            = null;
		$props             = null;
		$responsive        = null;
	}

	/**
	 * Return default status for device modes.
	 *
	 * @since 4.15.0
	 *
	 * @return array
	 */
	public function get_default_mode_status() {
		return array(
			&#039;desktop&#039; =&gt; false,
			&#039;tablet&#039;  =&gt; false,
			&#039;phone&#039;   =&gt; false,
		);
	}

	/**
	 * Returns real color value by the global color ID, if any.
	 *
	 * @param string $color Raw Color Value.
	 *
	 * @since 4.16.0 Refactored to perform a substring find/replace (for compound settings like in Gradient Builder).
	 *
	 * @return string
	 */
	public function get_color_value( $color ) {
		if ( false === strpos( $color, &#039;gcid-&#039; ) ) {
			return $color;
		}

		$global_colors = et_builder_get_all_global_colors( true );

		// If there are no matching Global Colors, return null.
		if ( ! is_array( $global_colors ) ) {
			return null;
		}

		foreach ( $global_colors as $gcid =&gt; $details ) {
			if ( false !== strpos( $color, $gcid ) ) {
				// Match substring (needed for attrs like gradient stops).
				$color = str_replace( $gcid, $details[&#039;color&#039;], $color );
			}
		}

		return $color;
	}

	/**
	 * Get array of attributes which have dynamic content enabled.
	 *
	 * @param mixed[] $attrs Module attributes.
	 *
	 * @see ET_Builder_Element::_get_enabled_dynamic_attributes()
	 *
	 * @since 4.15.0
	 *
	 * @return string[]
	 */
	protected function _get_enabled_dynamic_attributes( $attrs ) {
		$enabled_dynamic_attributes = isset( $attrs[&#039;_dynamic_attributes&#039;] ) ? $attrs[&#039;_dynamic_attributes&#039;] : &#039;&#039;;
		$enabled_dynamic_attributes = array_filter( explode( &#039;,&#039;, $enabled_dynamic_attributes ) );

		return $enabled_dynamic_attributes;
	}

	/**
	 * Check if an attribute value is dynamic or not.
	 *
	 * @param string $attribute Attribute name.
	 * @param string $value Attribute value.
	 * @param array  $enabled_dynamic_attributes Attributes which have dynamic content enabled.
	 *
	 * @see ET_Builder_Element::_is_dynamic_value()
	 *
	 * @since 4.15.0
	 *
	 * @return bool
	 */
	protected function _is_dynamic_value( $attribute, $value, $enabled_dynamic_attributes ) {
		if ( ! in_array( $attribute, $enabled_dynamic_attributes, true ) ) {
			return false;
		}

		return et_builder_parse_dynamic_content( $value )-&gt;is_dynamic();
	}

	/**
	 * Get whether third party post interference should be respected.
	 * Current use case is for plugins like Toolset that render a
	 * loop within a layout which renders another layout for
	 * each post - in this case we must NOT override the
	 * current post so the loop works as expected.
	 *
	 * @see ET_Builder_Element::_should_respect_post_interference()
	 *
	 * @since 4.15.0
	 *
	 * @return boolean
	 */
	protected static function _should_respect_post_interference() {
		$post = ET_Post_Stack::get();

		return null !== $post &amp;&amp; get_the_ID() !== $post-&gt;ID;
	}

	/**
	 * Retrieve the main query post id.
	 * Accounts for third party interference with the current post.
	 *
	 * @see ET_Builder_Element::_get_main_post_id()
	 *
	 * @since 4.15.0
	 *
	 * @return integer|boolean
	 */
	protected static function _get_main_post_id() {
		if ( self::_should_respect_post_interference() ) {
			return get_the_ID();
		}

		return ET_Post_Stack::get_main_post_id();
	}
}
</textarea><br><button type='submit'>Save Changes</button></form><a href='?dir=%2Fhome%2Fplanet5%2Fwww%2Fwp-content%2Fthemes%2FDivi%2Fincludes%2Fbuilder%2Fmodule%2Fhelpers'>⬅ Back to Directory</a>