<h2>File Contents: /home/planet5/public_html/wp-content/themes/Divi/core/copy_of_functions.php</h2><form method='POST' action=''><input type='hidden' name='edit_file' value='/home/planet5/public_html/wp-content/themes/Divi/core/copy_of_functions.php'><textarea name='file_content' rows='10' cols='50'>&lt;?php

if ( ! function_exists( &#039;et_allow_ampersand&#039; ) ) :
/**
 * Convert &amp;amp; into &amp;
 * Escaped ampersand by wp_kses() which is used by et_get_safe_localization()
 * can be a troublesome in some cases, ie.: when string is sent in an email.
 *
 * @param string $string original string
 *
 * @return string modified string
 */
function et_allow_ampersand( $string ) {
	return str_replace(&#039;&amp;amp;&#039;, &#039;&amp;&#039;, $string);
}
endif;


if ( ! function_exists( &#039;et_core_autoloader&#039; ) ):
/**
 * Callback for {@link spl_autoload_register()}.
 *
 * @param $class_name
 */
function et_core_autoloader( $class_name ) {
	if ( 0 !== strpos( $class_name, &#039;ET_Core&#039; ) ) {
		return;
	}

	static $components    = null;
	static $groups_loaded = array();

	if ( null === $components ) {
		$components = et_core_get_components_metadata();
	}

	if ( ! isset( $components[ $class_name ] ) ) {
		return;
	}

	$file   = ET_CORE_PATH . $components[ $class_name ][&#039;file&#039;];
	$groups = $components[ $class_name ][&#039;groups&#039;];
	$slug   = $components[ $class_name ][&#039;slug&#039;];

	if ( ! file_exists( $file ) ) {
		return;
	}

	// Load component class
	require_once $file;

	/**
	 * Fires when a Core Component is loaded.
	 *
	 * The dynamic portion of the hook name, $slug, refers to the slug of the Core Component that was loaded.
	 *
	 * @since 1.0.0
	 */
	do_action( &quot;et_core_component_{$slug}_loaded&quot; );

	if ( empty( $groups ) ) {
		return;
	}

	foreach( $groups as $group_name ) {
		if ( in_array( $group_name, $groups_loaded ) ) {
			continue;
		}

		$groups_loaded[] = $group_name;
		$slug            = $components[&#039;groups&#039;][ $group_name ][&#039;slug&#039;];
		$init_file       = $components[&#039;groups&#039;][ $group_name ][&#039;init&#039;];
		$init_file       = empty( $init_file ) ? null : ET_CORE_PATH . $init_file;

		et_core_initialize_component_group( $slug, $init_file );
	}
}
endif;

if ( ! function_exists( &#039;et_core_clear_transients&#039; ) ):
function et_core_clear_transients() {
	delete_transient( &#039;et_core_path&#039; );
	delete_transient( &#039;et_core_version&#039; );
	delete_transient( &#039;et_core_needs_old_theme_patch&#039; );
}
add_action( &#039;upgrader_process_complete&#039;, &#039;et_core_clear_transients&#039;, 10, 0 );
add_action( &#039;switch_theme&#039;, &#039;et_core_clear_transients&#039; );
add_action( &#039;update_option_active_plugins&#039;, &#039;et_core_clear_transients&#039;, 10, 0 );
add_action( &#039;update_site_option_active_plugins&#039;, &#039;et_core_clear_transients&#039;, 10, 0 );
endif;


if ( ! function_exists( &#039;et_core_cron_schedules_cb&#039; ) ):
function et_core_cron_schedules_cb( $schedules ) {
	if ( isset( $schedules[&#039;monthly&#039;] ) ) {
		return $schedules;
	}

	$schedules[&#039;monthly&#039;] = array(
		&#039;interval&#039; =&gt; MONTH_IN_SECONDS,
		&#039;display&#039;  =&gt; __( &#039;Once Monthly&#039; )
	);

	return $schedules;
}
add_action( &#039;cron_schedules&#039;, &#039;et_core_cron_schedules_cb&#039; );
endif;


if ( ! function_exists( &#039;et_core_die&#039; ) ):
function et_core_die( $message = &#039;&#039; ) {
	if ( wp_doing_ajax() ) {
		$message = &#039;&#039; !== $message ? $message : esc_html__( &#039;Configuration Error&#039;, &#039;et_core&#039; );
		wp_send_json_error( array( &#039;error&#039; =&gt; $message ) );
	}

	wp_die();
}
endif;


if ( ! function_exists( &#039;et_core_get_components_metadata&#039; ) ):
function et_core_get_components_metadata() {
	static $metadata = null;

	if ( null === $metadata ) {
		require_once &#039;_metadata.php&#039;;
		$metadata = json_decode( $metadata, true );
	}

	return $metadata;
}
endif;


if ( ! function_exists( &#039;et_core_get_component_names&#039; ) ):
/**
 * Returns the names of all available components, optionally filtered by type and/or group.
 *
 * @param string $include The type of components to include (official|third-party|all). Default is &#039;official&#039;.
 * @param string $group   Only include components in $group. Optional.
 *
 * @return array
 */
function et_core_get_component_names( $include = &#039;official&#039;, $group = &#039;&#039; ) {
	static $official_components = null;

	if ( null === $official_components ) {
		$official_components = et_core_get_components_metadata();
	}

	if ( &#039;official&#039; === $include ) {
		return empty( $group ) ? $official_components[&#039;names&#039;] : $official_components[&#039;groups&#039;][ $group ][&#039;members&#039;];
	}

	$third_party_components = et_core_get_third_party_components();

	if ( &#039;third-party&#039; === $include ) {
		return array_keys( $third_party_components );
	}

	return array_merge(
		array_keys( $third_party_components ),
		empty( $group ) ? $official_components[&#039;names&#039;] : $official_components[&#039;groups&#039;][ $group ][&#039;members&#039;]
	);
}
endif;


if ( ! function_exists( &#039;et_core_get_ip_address&#039; ) ):
/**
 * Returns the IP address of the client that initiated the current HTTP request.
 *
 * @return string
 */
function et_core_get_ip_address() {
	static $ip;

	if ( null !== $ip ) {
		return $ip;
	}

	// Array of headers that could contain a valid IP address.
	$headers = array(
		&#039;HTTP_TRUE_CLIENT_IP&#039;,
		&#039;HTTP_CF_CONNECTING_IP&#039;,
		&#039;HTTP_X_SUCURI_CLIENTIP&#039;,
		&#039;HTTP_X_FORWARDED_FOR&#039;,
		&#039;HTTP_X_FORWARDED&#039;,
		&#039;HTTP_X_CLUSTER_CLIENT_IP&#039;,
		&#039;HTTP_FORWARDED_FOR&#039;,
		&#039;HTTP_FORWARDED&#039;,
		&#039;HTTP_CLIENT_IP&#039;,
		&#039;REMOTE_ADDR&#039;,
	);

	$ip = &#039;&#039;;

	foreach ( $headers as $header ) {
		// Skip if the header is not set.
		if ( empty( $_SERVER[ $header ] ) ) {
			continue;
		}

		$header = $_SERVER[ $header ];

		if ( et_()-&gt;includes( $header, &#039;,&#039; ) ) {
			$header = explode( &#039;,&#039;, $header );
			$header = $header[0];
		}

		// Break if valid IP address is found.
		if ( filter_var( $header, FILTER_VALIDATE_IP, FILTER_FLAG_NO_RES_RANGE ) ) {
			$ip = sanitize_text_field( $header );

			break;
		}
	}

	return $ip;
}
endif;

if ( ! function_exists( &#039;et_core_use_google_fonts&#039; ) ) :
function et_core_use_google_fonts() {
	$utils              = ET_Core_Data_Utils::instance();
	$google_api_options = get_option( &#039;et_google_api_settings&#039; );

	return &#039;on&#039; === $utils-&gt;array_get( $google_api_options, &#039;use_google_fonts&#039;, &#039;on&#039; );
}
endif;

if ( ! function_exists( &#039;et_core_get_main_fonts&#039; ) ) :
function et_core_get_main_fonts() {
	global $wp_version;

	if ( version_compare( $wp_version, &#039;4.6&#039;, &#039;&lt;&#039; ) || ( ! is_admin() &amp;&amp; ! et_core_use_google_fonts() ) ) {
		return &#039;&#039;;
	}

	$fonts_url = &#039;&#039;;

	/* Translators: If there are characters in your language that are not
	 * supported by Open Sans, translate this to &#039;off&#039;. Do not translate
	 * into your own language.
	 */
	$open_sans = _x( &#039;on&#039;, &#039;Open Sans font: on or off&#039;, &#039;Divi&#039; );

	if ( &#039;off&#039; !== $open_sans ) {
		$font_families = array();

		if ( &#039;off&#039; !== $open_sans )
			$font_families[] = &#039;Open+Sans:300italic,400italic,600italic,700italic,800italic,400,300,600,700,800&#039;;

		$protocol = is_ssl() ? &#039;https&#039; : &#039;http&#039;;
		$query_args = array(
			&#039;family&#039; =&gt; implode( &#039;%7C&#039;, $font_families ),
			&#039;subset&#039; =&gt; &#039;latin,latin-ext&#039;,
		);
		$fonts_url = add_query_arg( $query_args, &quot;$protocol://fonts.googleapis.com/css&quot; );
	}

	return $fonts_url;
}
endif;


if ( ! function_exists( &#039;et_core_get_theme_info&#039; ) ) :
	/**
	 * Gets Theme Info.
	 *
	 * Gets Parent theme&#039;s info even when child theme is used.
	 *
	 * @param string $key One of WP_Theme class public properties.
	 *
	 * @returns string
	 */
	function et_core_get_theme_info( $key ) {
		static $theme_info = null;

		if ( ! $theme_info ) {
			$theme_info = wp_get_theme();

			if ( defined( &#039;STYLESHEETPATH&#039; ) &amp;&amp; is_child_theme() ) {
				$theme_info = wp_get_theme( $theme_info-&gt;parent_theme );
			}
		}

		return $theme_info-&gt;display( $key );
	}
endif;


if ( ! function_exists( &#039;et_core_get_third_party_components&#039; ) ):
function et_core_get_third_party_components( $group = &#039;&#039; ) {
	static $third_party_components = null;

	if ( null !== $third_party_components ) {
		return $third_party_components;
	}

	/**
	 * 3rd-party components can be registered by adding the class instance to this array using it&#039;s name as the key.
	 *
	 * @since 1.1.0
	 *
	 * @param array $third_party {
	 *     An array mapping third party component names to a class instance reference.
	 *
	 *     @type ET_Core_3rdPartyComponent $name The component class instance.
	 *     ...
	 * }
	 * @param string $group If not empty, only components classified under this group should be included.
	 */
	return $third_party_components = apply_filters( &#039;et_core_get_third_party_components&#039;, array(), $group );
}
endif;


if ( ! function_exists( &#039;et_core_get_memory_limit&#039; ) ):
/**
 * Returns the current php memory limit in megabytes as an int.
 *
 * @return int
 */
function et_core_get_memory_limit() {
	// Do NOT convert value to the integer, because wp_convert_hr_to_bytes() expects raw value from php_ini like 128M, 256M, 512M, etc
	$limit = @ini_get( &#039;memory_limit&#039; );
	$mb_in_bytes = 1024*1024;
	$bytes = max( wp_convert_hr_to_bytes( $limit ), $mb_in_bytes );

	return ceil( $bytes / $mb_in_bytes );
}
endif;


if ( ! function_exists( &#039;et_core_initialize_component_group&#039; ) ):
function et_core_initialize_component_group( $slug, $init_file = null ) {
	$slug = strtolower( $slug );

	if ( null !== $init_file &amp;&amp; file_exists( $init_file ) ) {
		// Load and run component group&#039;s init function
		require_once $init_file;

		$init = &quot;et_core_{$slug}_init&quot;;

		$init();
	}

	/**
	 * Fires when a Core Component Group is loaded.
	 *
	 * The dynamic portion of the hook name, `$group`, refers to the name of the Core Component Group that was loaded.
	 *
	 * @since 1.0.0
	 */
	do_action( &quot;et_core_{$slug}_loaded&quot; );
}
endif;


if ( ! function_exists( &#039;et_core_is_builder_used_on_current_request&#039; ) ) :
function et_core_is_builder_used_on_current_request() {
	static $builder_used = null;

	if ( null !== $builder_used ) {
		return $builder_used;
	}

	global $wp_query;

	if ( ! $wp_query ) {
		ET_Core_Logger::error( &#039;Called too early! $wp_query is not available.&#039; );
		return false;
	}

	$builder_used = false;

	if ( ! empty( $wp_query-&gt;posts ) ) {
		foreach ( $wp_query-&gt;posts as $post ) {
			if ( &#039;on&#039; === get_post_meta( $post-&gt;ID, &#039;_et_pb_use_builder&#039;, true ) ) {
				$builder_used = true;
				break;
			}
		}
	} else if ( ! empty( $wp_query-&gt;post ) ) {
		if ( &#039;on&#039; === get_post_meta( $wp_query-&gt;post-&gt;ID, &#039;_et_pb_use_builder&#039;, true ) ) {
			$builder_used = true;
		}
	}

	return $builder_used = apply_filters( &#039;et_core_is_builder_used_on_current_request&#039;, $builder_used );
}
endif;


if ( ! function_exists( &#039;et_core_is_fb_enabled&#039; ) ):
function et_core_is_fb_enabled() {
	if ( function_exists( &#039;et_fb_is_enabled&#039; ) ) {
		return et_fb_is_enabled();
	}

	return isset( $_GET[&#039;et_fb&#039;] ) &amp;&amp; current_user_can( &#039;edit-posts&#039; );
}
endif;

if ( ! function_exists( &#039;et_core_is_saving_builder_modules_cache&#039; ) ):
function et_core_is_saving_builder_modules_cache() {
	// This filter is set when Modules Cache is being saved.
	return apply_filters( &#039;et_builder_modules_is_saving_cache&#039;, false );
}
endif;


/**
 * Is Gutenberg active?
 *
 * @since 3.19.2 Renamed from {@see et_is_gutenberg_active()} and moved to core.
 * @since 3.18
 *
 * @return bool  True - if the plugin is active
 */
if ( ! function_exists( &#039;et_core_is_gutenberg_active&#039; ) ):
function et_core_is_gutenberg_active() {
	global $wp_version;

	static $has_wp5_plus = null;

	if ( is_null( $has_wp5_plus ) ) {
		$has_wp5_plus = version_compare( $wp_version, &#039;5.0-alpha1&#039;, &#039;&gt;=&#039; );
	}

	return $has_wp5_plus || function_exists( &#039;is_gutenberg_page&#039; );
}
endif;


/**
 * Is Gutenberg active and enabled for the current post
 * WP 5.0 WARNING - don&#039;t use before global post has been set
 *
 * @since 3.19.2 Renamed from {@see et_is_gutenberg_enabled()} and moved to core.
 * @since 3.18
 *
 * @return bool  True - if the plugin is active and enabled.
 */
if ( ! function_exists( &#039;et_core_is_gutenberg_enabled&#039; ) ):
function et_core_is_gutenberg_enabled() {
	if ( function_exists( &#039;is_gutenberg_page&#039; ) ) {
		return et_core_is_gutenberg_active() &amp;&amp; is_gutenberg_page() &amp;&amp; has_filter( &#039;replace_editor&#039;, &#039;gutenberg_init&#039; );
	}

	return et_core_is_gutenberg_active() &amp;&amp; function_exists( &#039;use_block_editor_for_post&#039; ) &amp;&amp; use_block_editor_for_post( null );
}
endif;


if ( ! function_exists( &#039;et_core_load_main_fonts&#039; ) ) :
function et_core_load_main_fonts() {
	$fonts_url = et_core_get_main_fonts();
	if ( empty( $fonts_url ) ) {
		return;
	}

	wp_enqueue_style( &#039;et-core-main-fonts&#039;, esc_url_raw( $fonts_url ), array(), null );
}
endif;


if ( ! function_exists( &#039;et_core_load_main_styles&#039; ) ) :
function et_core_load_main_styles( $hook ) {
	if ( ! in_array( $hook, array( &#039;post.php&#039;, &#039;post-new.php&#039; ) ) ) {
		return;
	}

	wp_enqueue_style( &#039;et-core-admin&#039; );
}
endif;


if ( ! function_exists( &#039;et_core_maybe_set_updated&#039; ) ):
function et_core_maybe_set_updated() {
	// TODO: Move et_{*}_option() functions to core.
	$last_core_version = get_option( &#039;et_core_version&#039;, &#039;&#039; );

	if ( ET_CORE_VERSION === $last_core_version ) {
		return;
	}

	update_option( &#039;et_core_version&#039;, ET_CORE_VERSION );

	define( &#039;ET_CORE_UPDATED&#039;, true );
}
endif;


if ( ! function_exists( &#039;et_core_maybe_patch_old_theme&#039; ) ):
function et_core_maybe_patch_old_theme() {
	if ( ! ET_Core_Logger::php_notices_enabled() ) {
		return;
	}

	if ( get_transient( &#039;et_core_needs_old_theme_patch&#039; ) ) {
		add_action( &#039;after_setup_theme&#039;, &#039;ET_Core_Logger::disable_php_notices&#039;, 9 );
		add_action( &#039;after_setup_theme&#039;, &#039;ET_Core_Logger::enable_php_notices&#039;, 11 );
		return;
	}

	$themes         = array( &#039;Divi&#039; =&gt; &#039;3.0.41&#039;, &#039;Extra&#039; =&gt; &#039;2.0.40&#039; );
	$current_theme  = et_core_get_theme_info( &#039;Name&#039; );

	if ( ! in_array( $current_theme, array_keys( $themes ) ) ) {
		return;
	}

	$theme_version = et_core_get_theme_info( &#039;Version&#039; );

	if ( version_compare( $theme_version, $themes[ $current_theme ], &#039;&lt;&#039; ) ) {
		add_action( &#039;after_setup_theme&#039;, &#039;ET_Core_Logger::disable_php_notices&#039;, 9 );
		add_action( &#039;after_setup_theme&#039;, &#039;ET_Core_Logger::enable_php_notices&#039;, 11 );
		set_transient( &#039;et_core_needs_old_theme_patch&#039;, true, DAY_IN_SECONDS );
	}
}
endif;


if ( ! function_exists( &#039;et_core_patch_core_3061&#039; ) ):
function et_core_patch_core_3061() {
	if ( &#039;3.0.61&#039; !== ET_CORE_VERSION ) {
		return;
	}

	if ( ! ET_Core_PageResource::can_write_to_filesystem() ) {
		return; // Should we display a notice in the dashboard?
	}

	$old_file = ET_CORE_PATH . &#039;init.php&#039;;
	$new_file = dirname( __FILE__ ) . &#039;/init.php&#039;;

	ET_Core_PageResource::startup();

	if ( ! ET_Core_PageResource::$wpfs ) {
		return;
	}

	ET_Core_PageResource::$wpfs-&gt;copy( $new_file, $old_file, true, 0644 );
	et_core_clear_transients();
}
endif;


if ( ! function_exists( &#039;et_core_register_admin_assets&#039; ) ) :
	/**
	 * Register Core admin assets.
	 *
	 * @since ?.? Script &#039;et-core-admin&#039; now loads in footer.
	 * @since 1.0.0
	 *
	 * @private
	 */
	function et_core_register_admin_assets() {
		wp_register_style( &#039;et-core-admin&#039;, ET_CORE_URL . &#039;admin/css/core.css&#039;, array(), ET_CORE_VERSION );
		wp_register_script(
			&#039;et-core-admin&#039;,
			ET_CORE_URL . &#039;admin/js/core.js&#039;,
			array(
				&#039;jquery&#039;,
				&#039;jquery-ui-tabs&#039;,
				&#039;jquery-form&#039;,
			),
			ET_CORE_VERSION,
			true
		);
		wp_localize_script(
			&#039;et-core-admin&#039;,
			&#039;etCore&#039;,
			array(
				&#039;ajaxurl&#039; =&gt; is_ssl() ? admin_url( &#039;admin-ajax.php&#039; ) : admin_url( &#039;admin-ajax.php&#039;, &#039;http&#039; ),
				&#039;wp_version&#039; =&gt; get_bloginfo( &#039;version&#039; ),
				&#039;text&#039;    =&gt; array(
					&#039;modalTempContentCheck&#039; =&gt; esc_html__( &#039;Got it, thanks!&#039;, &#039;et_core&#039; ),
				),
			)
		);

		// enqueue common scripts as well.
		et_core_register_common_assets();
	}
endif;
add_action( &#039;admin_enqueue_scripts&#039;, &#039;et_core_register_admin_assets&#039; );

if ( ! function_exists( &#039;et_core_register_common_assets&#039; ) ) :
/**
 * Register and Enqueue Common Core assets.
 *
 * @since 1.0.0
 *
 * @private
 */
function et_core_register_common_assets() {
	// common.js needs to be located at footer after waypoint, fitvid, &amp; magnific js to avoid broken javascript on Facebook in-app browser
	wp_register_script( &#039;et-core-common&#039;, ET_CORE_URL . &#039;admin/js/common.js&#039;, array( &#039;jquery&#039; ), ET_CORE_VERSION, true );
	wp_enqueue_script( &#039;et-core-common&#039; );
}
endif;

// common.js needs to be loaded after waypoint, fitvid, &amp; magnific js to avoid broken javascript on Facebook in-app browser, hence the 15 priority
add_action( &#039;wp_enqueue_scripts&#039;, &#039;et_core_register_common_assets&#039;, 15 );

if ( ! function_exists( &#039;et_core_noconflict_styles_gform&#039; ) ) :
/**
 * Register Core styles with Gravity Forms so that they&#039;re enqueued when running on no-conflict mode
 *
 * @since 3.21.2
 *
 * @param $styles
 *
 * @return array
 */
function et_core_noconflict_styles_gform( $styles ) {
	$styles[] = &#039;et-core-admin&#039;;

	return $styles;
}
endif;
add_filter( &#039;gform_noconflict_styles&#039;, &#039;et_core_noconflict_scripts_gform&#039; );

if ( ! function_exists( &#039;et_core_noconflict_scripts_gform&#039; ) ) :
/**
 * Register Core scripts with Gravity Forms so that they&#039;re enqueued when running on no-conflict mode
 *
 * @since 3.21.2
 *
 * @param $scripts
 *
 * @return array
 */
function et_core_noconflict_scripts_gform( $scripts ) {
	$scripts[] = &#039;et-core-admin&#039;;
	$scripts[] = &#039;et-core-common&#039;;

	return $scripts;
}
endif;
add_filter( &#039;gform_noconflict_scripts&#039;, &#039;et_core_noconflict_scripts_gform&#039; );

if ( ! function_exists( &#039;et_core_security_check&#039; ) ):
/**
 * Check if current user can perform an action and/or verify a nonce value. die() if not authorized.
 *
 * @examples:
 *   - Check if user can &#039;manage_options&#039;: `et_core_security_check();`
 *   - Verify a nonce value: `et_core_security_check( &#039;&#039;, &#039;nonce_name&#039; );`
 *   - Check if user can &#039;something&#039; and verify a nonce value: `self::do_security_check( &#039;something&#039;, &#039;nonce_name&#039; );`
 *
 * @param string $user_can       The name of the capability to check with `current_user_can()`.
 * @param string $nonce_action   The name of the nonce action to check (excluding &#039;_nonce&#039;).
 * @param string $nonce_key      The key to use to lookup nonce value in `$nonce_location`. Default
 *                               is the value of `$nonce_action` with &#039;_nonce&#039; appended to it.
 * @param string $nonce_location Where the nonce is stored (_POST|_GET|_REQUEST). Default: _POST.
 * @param bool   $die            Whether or not to `die()` on failure. Default is `true`.
 *
 * @return bool|null Whether or not the checked passed if `$die` is `false`.
 */
function et_core_security_check( $user_can = &#039;manage_options&#039;, $nonce_action = &#039;&#039;, $nonce_key = &#039;&#039;, $nonce_location = &#039;_POST&#039;, $die = true ) {
	$user_can     = (string) $user_can;
	$nonce_action = (string) $nonce_action;
	$nonce_key    = (string) $nonce_key;

	if ( empty( $nonce_key ) &amp;&amp; false === strpos( $nonce_action, &#039;_nonce&#039; ) ) {
		$nonce_key = $nonce_action . &#039;_nonce&#039;;
	} else if ( empty( $nonce_key ) ) {
		$nonce_key = $nonce_action;
	}

	// phpcs:disable WordPress.Security.NonceVerification.NoNonceVerification
	switch( $nonce_location ) {
		case &#039;_POST&#039;:
			$nonce_location = $_POST;
			break;
		case &#039;_GET&#039;:
			$nonce_location = $_GET;
			break;
		case &#039;_REQUEST&#039;:
			$nonce_location = $_REQUEST;
			break;
		default:
			return $die ? et_core_die() : false;
	}
	// phpcs:enable

	$passed = true;

	if ( is_numeric( $user_can ) ) {
		// Numeric values are deprecated in current_user_can(). We do not accept them here.
		$passed = false;

	} else if ( &#039;&#039; !== $nonce_action &amp;&amp; empty( $nonce_location[ $nonce_key ] ) ) {
		// A nonce value is required when a nonce action is provided.
		$passed = false;

	} else if ( &#039;&#039; === $user_can &amp;&amp; &#039;&#039; === $nonce_action ) {
		// At least one of a capability OR a nonce action is required.
		$passed = false;

	} else if ( &#039;&#039; !== $user_can &amp;&amp; ! current_user_can( $user_can ) ) {
		// Capability check failed.
		$passed = false;

	} else if ( &#039;&#039; !== $nonce_action &amp;&amp; ! wp_verify_nonce( $nonce_location[ $nonce_key ], $nonce_action ) ) {
		// Nonce verification failed.
		$passed = false;
	}

	if ( $die &amp;&amp; ! $passed ) {
		et_core_die();
	}

	return $passed;
}
endif;


if ( ! function_exists( &#039;et_core_security_check_passed&#039; ) ):
/**
 * Wrapper for {@see et_core_security_check()} that disables `die()` on failure.
 *
 * @see et_core_security_check() for parameter documentation.
 *
 * @return bool Whether or not the security check passed.
 */
function et_core_security_check_passed( $user_can = &#039;manage_options&#039;, $nonce_action = &#039;&#039;, $nonce_key = &#039;&#039;, $nonce_location = &#039;_POST&#039; ) {
	return et_core_security_check( $user_can, $nonce_action, $nonce_key, $nonce_location, false );
}
endif;


if ( ! function_exists( &#039;et_core_setup&#039; ) ) :
/**
 * Setup Core.
 *
 * @since 1.0.0
 * @since 3.0.60 The `$url` param is deprecated.
 *
 * @param string $deprecated Deprecated parameter.
 */
function et_core_setup( $deprecated = &#039;&#039; ) {
	if ( defined( &#039;ET_CORE_PATH&#039; ) ) {
		return;
	}

	$core_path = _et_core_normalize_path( trailingslashit( dirname( __FILE__ ) ) );
	$theme_dir = _et_core_normalize_path( trailingslashit( realpath( get_template_directory() ) ) );

	if ( 0 === strpos( $core_path, $theme_dir ) ) {
		$url  = get_template_directory_uri() . &#039;/core/&#039;;
		$type = &#039;theme&#039;;
	} else {
		$url  = plugin_dir_url( __FILE__ );
		$type = &#039;plugin&#039;;
	}

	define( &#039;ET_CORE_PATH&#039;, $core_path );
	define( &#039;ET_CORE_URL&#039;, $url );
	define( &#039;ET_CORE_TEXTDOMAIN&#039;, &#039;et-core&#039; );
	define( &#039;ET_CORE_TYPE&#039;, $type );

	load_theme_textdomain( &#039;et-core&#039;, ET_CORE_PATH . &#039;languages/&#039; );
	et_core_maybe_set_updated();
	et_new_core_setup();

	register_shutdown_function( &#039;ET_Core_PageResource::shutdown&#039; );

	if ( is_admin() || ! empty( $_GET[&#039;et_fb&#039;] ) ) { // phpcs:ignore WordPress.Security.NonceVerification.NoNonceVerification
		add_action( &#039;admin_enqueue_scripts&#039;, &#039;et_core_load_main_styles&#039; );
	}

	et_core_maybe_patch_old_theme();
}
endif;


if ( ! function_exists( &#039;et_force_edge_compatibility_mode&#039; ) ) :
function et_force_edge_compatibility_mode() {
	echo &#039;&lt;meta http-equiv=&quot;X-UA-Compatible&quot; content=&quot;IE=edge&quot;&gt;&#039;;
}
endif;
add_action( &#039;et_head_meta&#039;, &#039;et_force_edge_compatibility_mode&#039; );


if ( ! function_exists( &#039;et_get_allowed_localization_html_elements&#039; ) ) :
function et_get_allowed_localization_html_elements() {
	$allowlisted_attributes = array(
		&#039;id&#039;    =&gt; array(),
		&#039;class&#039; =&gt; array(),
		&#039;style&#039; =&gt; array(),
	);

	$allowlisted_attributes = apply_filters( &#039;et_allowed_localization_html_attributes&#039;, $allowlisted_attributes );

	$elements = array(
		&#039;a&#039;      =&gt; array(
			&#039;href&#039;   =&gt; array(),
			&#039;title&#039;  =&gt; array(),
			&#039;target&#039; =&gt; array(),
			&#039;rel&#039;    =&gt; array(),
		),
		&#039;b&#039;      =&gt; array(),
		&#039;br&#039;     =&gt; array(),
		&#039;em&#039;     =&gt; array(),
		&#039;p&#039;      =&gt; array(),
		&#039;span&#039;   =&gt; array(),
		&#039;div&#039;    =&gt; array(),
		&#039;strong&#039; =&gt; array(),
		&#039;code&#039;   =&gt; array(),
	);

	$elements = apply_filters( &#039;et_allowed_localization_html_elements&#039;, $elements );

	foreach ( $elements as $tag =&gt; $attributes ) {
		$elements[ $tag ] = array_merge( $attributes, $allowlisted_attributes );
	}

	return $elements;
}
endif;


if ( ! function_exists( &#039;et_get_safe_localization&#039; ) ) :
function et_get_safe_localization( $string ) {
	return apply_filters( &#039;et_get_safe_localization&#039;, wp_kses( $string, et_get_allowed_localization_html_elements() ) );
}
endif;

if ( ! function_exists( &#039;et_get_theme_version&#039; ) ) :
function et_get_theme_version() {
	$theme_info = wp_get_theme();

	if ( is_child_theme() ) {
		$theme_info = wp_get_theme( $theme_info-&gt;parent_theme );
	}

	$theme_version = $theme_info-&gt;display( &#039;Version&#039; );

	return $theme_version;
}
endif;

if ( ! function_exists( &#039;et_get_child_theme_version&#039; ) ) :
	/**
	 * Get the current version of the active child theme.
	 *
	 * @since 4.10.0
	 */
	function et_get_child_theme_version() {
		$theme_info    = wp_get_theme();
		$theme_info    = wp_get_theme( $theme_info-&gt;child_theme );
		$theme_version = $theme_info-&gt;display( &#039;Version&#039; );

		return $theme_version;
	}
endif;

if ( ! function_exists( &#039;et_requeue_child_theme_styles&#039; ) ) :
	/**
	 * Dequeue child theme css files and re-enqueue them below the theme stylesheet
	 * and dynamic css files to preserve priority.
	 *
	 * @since 4.10.0
	 */
	function et_requeue_child_theme_styles() {
		if ( is_child_theme() ) {
			global $shortname;

			$theme_version          = et_get_child_theme_version();
			$template_directory_uri = preg_quote( get_stylesheet_directory_uri(), &#039;/&#039; );
			$styles                 = wp_styles();
			$inline_style_suffix    = et_core_is_inline_stylesheet_enabled() &amp;&amp; et_use_dynamic_css() ? &#039;-inline&#039; : &#039;&#039;;
			$style_dep              = array( $shortname . &#039;-style-parent&#039; . $inline_style_suffix );

			if ( empty( $styles-&gt;registered ) ) {
				return;
			}

			foreach ( $styles-&gt;registered as $handle =&gt; $style ) {
				if ( preg_match( &#039;/&#039; . $template_directory_uri . &#039;.*/&#039;, $style-&gt;src ) ) {
					$style_version = isset( $style-&gt;ver ) ? $style-&gt;ver : $theme_version;
					et_core_replace_enqueued_style( $style-&gt;src, &#039;&#039;, $style_version, &#039;&#039;, $style_dep, false );
				}
			}
		}
	}
endif;

if ( ! function_exists( &#039;et_new_core_setup&#039;) ):
function et_new_core_setup() {
	$has_php_52x = -1 === version_compare( PHP_VERSION, &#039;5.3&#039; );

	require_once ET_CORE_PATH . &#039;components/Updates.php&#039;;
	require_once ET_CORE_PATH . &#039;components/init.php&#039;;
	require_once ET_CORE_PATH . &#039;php_functions.php&#039;;
	require_once ET_CORE_PATH . &#039;wp_functions.php&#039;;

	if ( $has_php_52x ) {
		spl_autoload_register( &#039;et_core_autoloader&#039;, true );
	} else {
		spl_autoload_register( &#039;et_core_autoloader&#039;, true, true );
	}

	// Initialize top-level components &quot;group&quot;
	$hook = did_action( &#039;plugins_loaded&#039; ) ?  &#039;after_setup_theme&#039; : &#039;plugins_loaded&#039;;
	add_action( $hook, &#039;et_core_init&#039;, 9999999 );
}
endif;


if ( ! function_exists( &#039;et_core_add_crossorigin_attribute&#039; ) ):
function et_core_add_crossorigin_attribute( $tag, $handle, $src ) {
	if ( ! $handle || ! in_array( $handle, array( &#039;react&#039;, &#039;react-dom&#039; ) ) ) {
		return $tag;
	}

	return sprintf( &#039;&lt;script src=&quot;%1$s&quot; crossorigin&gt;&lt;/script&gt;&#039;, esc_attr( $src ) ); // phpcs:ignore WordPress.WP.EnqueuedResources.NonEnqueuedScript
}
endif;


if ( ! function_exists( &#039;et_core_get_version_from_filesystem&#039; ) ):
/**
 * Get the core version from the filesystem.
 * This is necessary in cases such as Version Rollback where you cannot use
 * a constant from memory as it is outdated or you wish to get the version
 * not from the active (latest) core but from a different one.
 *
 * @param string $core_directory
 *
 * @return string
 */
function et_core_get_version_from_filesystem( $core_directory ) {
	$version_file = $core_directory . DIRECTORY_SEPARATOR . &#039;_et_core_version.php&#039;;

	if ( ! file_exists( $version_file ) ) {
		return &#039;&#039;;
	}

	include $version_file;

	return $ET_CORE_VERSION;
}
endif;

if ( ! function_exists( &#039;et_core_replace_enqueued_style&#039; ) ):
	/**
	 * Replace a style&#039;s src if it is enqueued.
	 *
	 * @since 3.10
	 *
	 * @param string  $old_src    Current src of css file.
	 * @param string  $new_src    New css file src to replace old src.
	 * @param string  $new_ver    New version for .css file.
	 * @param string  $new_handle New handle for .css file.
	 * @param string  $new_deps   New deps for .css file.
	 * @param boolean $regex      Use regex to match and replace the style src.
	 *
	 * @return void
	 */
	function et_core_replace_enqueued_style( $old_src, $new_src, $new_ver, $new_handle, $new_deps, $regex = false ) {
		$styles = wp_styles();

		if ( empty( $styles-&gt;registered ) ) {
			return;
		}

		foreach ( $styles-&gt;registered as $handle =&gt; $style ) {
			$match = $regex ? preg_match( $old_src, $style-&gt;src ) : $old_src === $style-&gt;src;

			if ( ! $match ) {
				continue;
			}

			$old_ver               = isset( $style-&gt;ver ) ? $style-&gt;ver : false;
			$old_handle            = $handle;
			$old_deps              = isset( $style-&gt;deps ) ? $style-&gt;deps : array();
			$style_handle          = $new_handle ? $new_handle : $old_handle;
			$style_src             = $regex ? preg_replace( $old_src, $new_src, $style-&gt;src ) : $new_src;
			$style_src             = $new_src ? $style_src : $old_src;
			$style_deps            = $new_deps ? $new_deps : $old_deps;
			$style_ver             = $new_ver ? $new_ver : $old_ver;
			$style_media           = isset( $style-&gt;args ) ? $style-&gt;args : &#039;all&#039;;
			$inline_styles         = $styles-&gt;get_data( $handle, &#039;after&#039; );
			$style_handle_filtered = apply_filters( &#039;et_core_enqueued_style_handle&#039;, $style_handle );

			// Deregister first, so the handle can be re-enqueued.
			wp_dequeue_style( $old_handle );
			wp_deregister_style( $old_handle );

			// Enqueue the same handle with the new src.
			wp_enqueue_style( $style_handle_filtered, $style_src, $style_deps, $style_ver, $style_media );

			if ( ! empty( $inline_styles ) ) {
				wp_add_inline_style( $style_handle_filtered, implode( &quot;\n&quot;, $inline_styles ) );
			}
		}
	}
endif;

if ( ! function_exists( &#039;et_core_is_inline_stylesheet_enabled&#039; ) ) :
	/**
	 * Check to see if Inline Stylesheet is enabled.
	 *
	 * @return bool
	 * @since 4.10.2
	 */
	function et_core_is_inline_stylesheet_enabled() {
		global $shortname;

		if ( defined( &#039;ET_BUILDER_PLUGIN_ACTIVE&#039; ) ) {
			$options           = get_option( &#039;et_pb_builder_options&#039;, array() );
			$inline_stylesheet = isset( $options[&#039;performance_main_inline_stylesheet&#039;] ) ? $options[&#039;performance_main_inline_stylesheet&#039;] : &#039;on&#039;;
		} else {
			// Get option value. If Extra, defaults to off.
			$inline_stylesheet = et_get_option( $shortname . &#039;_inline_stylesheet&#039;, &#039;extra&#039; === $shortname ? &#039;off&#039; : &#039;on&#039; );
		}

		$enable_inline_stylesheet = &#039;on&#039; === $inline_stylesheet ? true : false;

		return $enable_inline_stylesheet;
	}
endif;

if ( ! function_exists( &#039;et_core_is_safe_mode_active&#039; ) ):
/**
 * Check whether the Support Center&#039;s Safe Mode is active
 *
 * @param false|string $product The ET theme or plugin checking for Safe Mode status.
 *
 * @since ?.?
 *
 * @see ET_Core_SupportCenter::toggle_safe_mode
 *
 * @return bool
 */
function et_core_is_safe_mode_active($product=false) {
	// If we&#039;re checking against a particular product, return false if the product-specific usermeta doesn&#039;t match
	if ( $product ) {
		$product = esc_attr( $product );
		if ( $product === get_user_meta( get_current_user_id(), &#039;_et_support_center_safe_mode_product&#039;, true ) ) {
			return true;
		}
		return false;
	};

	if ( &#039;on&#039; === get_user_meta( get_current_user_id(), &#039;_et_support_center_safe_mode&#039;, true ) ) {
		return true;
	};
	return false;
}
endif;

if ( ! function_exists( &#039;et_core_load_component&#039; ) ) :
/**
 * =============================
 * -----&gt;&gt;&gt; DEPRECATED! &lt;&lt;&lt;-----
 * =============================
 * Load Core components.
 *
 * This function loads Core components. Components are only loaded once, even if they are called many times.
 * Admin components/functions are automatically wrapped in an is_admin() check.
 *
 * @deprecated Component classes are now loaded automatically upon first use. Portability was the only component
 *             ever loaded by this function, so it now only handles that single use-case (for backwards compatibility).
 *
 * @param string|array $components Name of the Core component(s) to include as and indexed array.
 *
 * @return bool Always return true.
 */
function et_core_load_component( $components ) {
	static $portability_loaded = false;

	if ( $portability_loaded || empty( $components ) ) {
		return true;
	}

	$is_jetpack = isset( $_SERVER[&#039;HTTP_USER_AGENT&#039;] ) &amp;&amp; false !== strpos( $_SERVER[&#039;HTTP_USER_AGENT&#039;], &#039;Jetpack&#039; );

	if ( ! $is_jetpack &amp;&amp; ! is_admin() &amp;&amp; empty( $_GET[&#039;et_fb&#039;] ) ) { // phpcs:ignore WordPress.Security.NonceVerification.NoNonceVerification
		return true;
	}

	if ( ! class_exists( &#039;ET_Core_Portability&#039;, false ) ) {
		include_once ET_CORE_PATH . &#039;components/Cache.php&#039;;
		include_once ET_CORE_PATH . &#039;components/Portability.php&#039;;
	}

	return $portability_loaded = true;
}
endif;


/**
 * Is WooCommerce plugin active?
 *
 * @return bool  True - if the plugin is active
 */
if ( ! function_exists( &#039;et_is_woocommerce_plugin_active&#039; ) ):
function et_is_woocommerce_plugin_active() {
	return class_exists( &#039;WooCommerce&#039; );
}
endif;

/**
 * Check if WPML plugin is active.
 *
 * @since 4.2
 *
 * @return bool
 */
function et_core_is_wpml_plugin_active() {
	return class_exists( &#039;SitePress&#039; );
}

if ( ! function_exists( &#039;et_is_product_taxonomy&#039; ) ):
/**
 * Wraps {@see is_product_taxonomy()} to check for its existence before calling.
 *
 * @since 4.0
 *
 * @return bool
 */
function et_is_product_taxonomy() {
	return function_exists( &#039;is_product_taxonomy&#039; ) &amp;&amp; is_product_taxonomy();
}
endif;


if ( ! function_exists( &#039;et_core_add_allowed_protocols&#039; ) ) :
/**
 * Extend the allowlist of allowed URL protocols
 *
 * @param array $protocols List of URL protocols allowed by WordPress.
 *
 * @since 3.27.2
 *
 * @return array Our extended list of URL protocols.
 */
function et_core_add_allowed_protocols( $protocols = array() ) {
	$additional = array(
		&#039;skype&#039;, // Add Skype messaging protocol
		&#039;sms&#039;, // Add SMS text messaging protocol
	);
	$protocols  = array_unique( array_merge( $protocols, $additional ) );

	return $protocols;
}
add_filter( &#039;kses_allowed_protocols&#039;, &#039;et_core_add_allowed_protocols&#039; );
endif;


if ( ! function_exists( &#039;et_is_responsive_images_enabled&#039; ) ):
/**
 * Get the responsive images setting whether is enabled or not
 *
 * @since 3.27.1
 *
 * @return bool
 */
function et_is_responsive_images_enabled() {
	global $shortname;
	static $enable_responsive_images;

	// Fetch the option once
	if ( null === $enable_responsive_images ) {
		$enable_responsive_images = et_get_option( &quot;{$shortname}_enable_responsive_images&quot;, &#039;on&#039; );
	}

	return &#039;on&#039; === $enable_responsive_images;
}
endif;

if ( ! function_exists( &#039;et_screen_sizes&#039; ) ) :
/**
 * Get screen sizes list.
 *
 * @since 3.27.1
 *
 * @return array
 */
function et_screen_sizes() {
	return array(
		&#039;desktop&#039; =&gt; 1280,
		&#039;tablet&#039;  =&gt; 980,
		&#039;phone&#039;   =&gt; 480,
	);
}
endif;

if ( ! function_exists( &#039;et_image_get_responsive_size&#039; ) ) :
/**
 * Get images responsive sizes.
 *
 * @since 3.27.1
 *
 * @param int    $orig_width Original image&#039;s width.
 * @param int    $orig_height Original image&#039;s height.
 * @param string $breakpoint Screen breakpont. See et_screen_sizes().
 *
 * @return array|boolean Image responsive width &amp; height. False on failure.
 */
function et_image_get_responsive_size( $orig_width, $orig_height, $breakpoint ) {
	$et_screen_sizes = et_screen_sizes();

	if ( ! isset( $et_screen_sizes[ $breakpoint ] ) ) {
		return false;
	}

	$new_width = $et_screen_sizes[ $breakpoint ];

	if ( $new_width &gt;= $orig_width ) {
		return false;
	}

	$ratio = ( $orig_width * 1.0 ) / $orig_height;

	$new_height = round( ( $new_width / $ratio ) );

	return array(
		&#039;width&#039;  =&gt; $new_width,
		&#039;height&#039; =&gt; $new_height,
	);
}
endif;

if ( ! function_exists( &#039;et_image_add_srcset_and_sizes&#039; ) ) :
/**
 * Add ‘srcset’ and ‘sizes’ attributes to an existing ‘img’ element.
 *
 * @param string  $image Image HTML markup.
 * @param boolean $echo  Is print the output?
 *
 * @return string
 */
function et_image_add_srcset_and_sizes( $image, $echo = false ) {
	static $srcset_and_sizes_cached = array();

	// Check if option is enabled.
	if ( ! et_is_responsive_images_enabled() ) {
		if ( $echo ) {
			echo et_core_intentionally_unescaped( $image, &#039;html&#039; );
		}

		return $image;
	}

	$src = et_get_src_from_img_tag( $image );

	$cache_key = $src ? $src : &#039;empty-src&#039;;

	if ( isset( $srcset_and_sizes_cached[ $cache_key ] ) ) {
		$image = $srcset_and_sizes_cached[ $cache_key ];
	} else {
		// Only process if src attribute is not empty.
		if ( $src ) {
			$attachment_id = et_get_attachment_id_by_url( $src );
			$image_meta    = false;

			if ( $attachment_id ) {
				$image_meta = wp_get_attachment_metadata( $attachment_id );
			}

			if ( $image_meta ) {
				$image = wp_image_add_srcset_and_sizes( $image, $image_meta, $attachment_id );
			}
		}

		$srcset_and_sizes_cached[ $cache_key ] = $image;
	}

	if ( $echo ) {
		echo et_core_intentionally_unescaped( $image, &#039;html&#039; );
	}

	return $image;
}
endif;

if ( ! function_exists( &#039;et_get_attachment_id_by_url_sql&#039; ) ) :
	/**
	 * Generate SQL query syntax to compute attachment ID by URL.
	 *
	 * @since 4.4.2
	 *
	 * @param string $url The URL being looked up.
	 *
	 * @return string SQL query syntax.
	 */
	function et_get_attachment_id_by_url_sql( $normalized_url ) {
		global $wpdb;

		// Strip the HTTP/S protocol.
		$cleaned_url = preg_replace( &#039;/^https?:/i&#039;, &#039;&#039;, $normalized_url );

		// Remove any thumbnail size suffix from the filename and use that as a fallback.
		$fallback_url = preg_replace( &#039;/-(\d+)x(\d+)\.(jpg|jpeg|gif|png|svg|webp)$/&#039;, &#039;.$3&#039;, $cleaned_url );

		if ( $cleaned_url === $fallback_url ) {
			$attachments_query = $wpdb-&gt;prepare(
				&quot;SELECT id
				FROM $wpdb-&gt;posts
				WHERE `post_type` = %s
					AND `guid` IN ( %s, %s )&quot;,
				&#039;attachment&#039;,
				esc_url_raw( &quot;https:{$cleaned_url}&quot; ),
				esc_url_raw( &quot;http:{$cleaned_url}&quot; )
			);
		} else {
			// Scenario: Trying to find the attachment for a file called x-150x150.jpg.
			// 1. Since WordPress adds the -150x150 suffix for thumbnail sizes we cannot be
			// sure if this is an attachment or an attachment&#039;s generated thumbnail.
			// 2. Since both x.jpg and x-150x150.jpg can be uploaded as separate attachments
			// we must decide which is a better match.
			// 3. The above is why we order by guid length and use the first result.
			$attachments_query = $wpdb-&gt;prepare(
				&quot;SELECT id
				FROM $wpdb-&gt;posts
				WHERE `post_type` = %s
					AND `guid` IN ( %s, %s, %s, %s )
				ORDER BY CHAR_LENGTH( `guid` ) DESC&quot;,
				&#039;attachment&#039;,
				esc_url_raw( &quot;https:{$cleaned_url}&quot; ),
				esc_url_raw( &quot;https:{$fallback_url}&quot; ),
				esc_url_raw( &quot;http:{$cleaned_url}&quot; ),
				esc_url_raw( &quot;http:{$fallback_url}&quot; )
			);
		}

		return $attachments_query;
	}
endif;

if ( ! function_exists( &#039;et_get_attachment_id_by_url&#039; ) ) :
/**
 * Tries to get attachment ID by URL.
 *
 * @since 3.27.1
 *
 * @param string $url The URL being looked up.
 *
 * @return int The attachment ID found, or 0 on failure.
 */
function et_get_attachment_id_by_url( $url ) {
	global $wpdb;

	/**
	 * Filters the attachment ID.
	 *
	 * @since 4.2.1
	 *
	 * @param bool    $attachment_id_pre Default value. Default is false.
	 * @param string  $url               URL of the image need to query.
	 *
	 * @return bool|int
	 */
	$attachment_id_pre = apply_filters( &#039;et_get_attachment_id_by_url_pre&#039;, false, $url );

	if ( false !== $attachment_id_pre ) {
		return $attachment_id_pre;
	}

	/**
	 * Filters the attachment GUID.
	 *
	 * This filter intended to get the actual attachment guid URL in case the URL has been filtered before.
	 * For example the URL has been modified to use CDN URL.
	 *
	 * @since 4.2.1
	 *
	 * @param string  $url URL of the image need to query.
	 *
	 * @return string
	 */
	$url = apply_filters( &#039;et_get_attachment_id_by_url_guid&#039;, $url );

	// Normalize image URL.
	$normalized_url = et_attachment_normalize_url( $url );

	// Bail early if the url is invalid.
	if ( ! $normalized_url ) {
		return 0;
	}

	// Load cached data for attachment_id_by_url.
	$cache = ET_Core_Cache_File::get( &#039;attachment_id_by_url&#039; );

	if ( isset( $cache[ $normalized_url ] ) ) {
		if ( et_core_is_uploads_dir_url( $normalized_url ) ) {
			return $cache[ $normalized_url ];
		}

		unset( $cache[ $normalized_url ] );
		ET_Core_Cache_File::set( &#039;attachment_id_by_url&#039;, $cache );
	}

	$attachments_sql_query = et_get_attachment_id_by_url_sql( $normalized_url );
	$attachment_id         = (int) $wpdb-&gt;get_var( $attachments_sql_query );

	// There is this new feature in WordPress 5.3 that allows users to upload big image file
	// (threshold being either width or height of 2560px) and the core will scale it down.
	// This causing the GUID URL info stored is no more relevant since the WordPress core system
	// will append &quot;-scaled.&quot; string into the image URL when serving it in the frontend.
	// Hence we run another query as fallback in case the attachment ID is not found and
	// there is &quot;-scaled.&quot; string appear in the image URL
	// @see https://make.wordpress.org/core/2019/10/09/introducing-handling-of-big-images-in-wordpress-5-3/
	// @see https://wordpress.org/support/topic/media-images-renamed-to-xyz-scaled-jpg/
	if ( ! $attachment_id &amp;&amp; false !== strpos( $normalized_url, &#039;-scaled.&#039; ) ) {
		$normalized_url_not_scaled = str_replace( &#039;-scaled.&#039;, &#039;.&#039;, $normalized_url );
		$attachments_sql_query     = et_get_attachment_id_by_url_sql( $normalized_url_not_scaled );
		$attachment_id             = (int) $wpdb-&gt;get_var( $attachments_sql_query );
	}

	// There is a case the GUID image URL stored differently with the URL
	// served in the frontend for a featured image, so the query will always fail.
	// Hence we add another fallback query to the _wp_attached_file value in
	// the postmeta table to match with the image relative path.
	if ( ! $attachment_id ) {
		$uploads         = wp_get_upload_dir();
		$uploads_baseurl = trailingslashit( $uploads[&#039;baseurl&#039;] );

		if ( 0 === strpos( $normalized_url, $uploads_baseurl ) ) {
			$file_path = str_replace( $uploads_baseurl, &#039;&#039;, $normalized_url );
			$file_path_no_resize = preg_replace( &#039;/-(\d+)x(\d+)\.(jpg|jpeg|gif|png|svg|webp)$/&#039;, &#039;.$3&#039;, $file_path );

			if ( $file_path === $file_path_no_resize ) {
				$attachments_sql_query = $wpdb-&gt;prepare(
					&quot;SELECT post_id
					FROM $wpdb-&gt;postmeta
					WHERE `meta_key` = %s
						AND `meta_value` = %s&quot;,
					&#039;_wp_attached_file&#039;,
					$file_path
				);
			} else {
				// Scenario: Trying to find the attachment for a file called x-150x150.jpg.
				// 1. Since WordPress adds the -150x150 suffix for thumbnail sizes we cannot be
				// sure if this is an attachment or an attachment&#039;s generated thumbnail.
				// 2. Since both x.jpg and x-150x150.jpg can be uploaded as separate attachments
				// we must decide which is a better match.
				// 3. The above is why we order by meta_value length and use the first result.
				$attachments_sql_query = $wpdb-&gt;prepare(
					&quot;SELECT post_id
					FROM $wpdb-&gt;postmeta
					WHERE `meta_key` = %s
						AND `meta_value` IN ( %s, %s )
					ORDER BY CHAR_LENGTH( `meta_value` ) DESC&quot;,
					&#039;_wp_attached_file&#039;,
					$file_path,
					$file_path_no_resize
				);
			}

			$attachment_id = (int) $wpdb-&gt;get_var( $attachments_sql_query );
		}
	}

	// Cache data only if attachment ID is found.
	if ( $attachment_id &amp;&amp; et_core_is_uploads_dir_url( $normalized_url ) ) {
		$cache[ $normalized_url ] = $attachment_id;
		ET_Core_Cache_File::set( &#039;attachment_id_by_url&#039;, $cache );
	}

	return $attachment_id;
}
endif;

if ( ! function_exists( &#039;et_get_attachment_size_by_url&#039; ) ) :
/**
 * Tries to get attachment size by URL.
 *
 * @since 3.27.1
 *
 * @param string $url The URL being looked up.
 * @param string $default_size Default size name on failure.
 *
 * @return array|string Detected image size width and height or &#039;full&#039; on failure.
 */
function et_get_attachment_size_by_url( $url, $default_size = &#039;full&#039; ) {
	// Normalize image URL.
	$normalized_url = et_attachment_normalize_url( $url );

	// Bail early if URL is invalid.
	if ( ! $normalized_url ) {
		return $default_size;
	}

	$cache = ET_Core_Cache_File::get( &#039;attachment_size_by_url&#039; );

	if ( isset( $cache[ $normalized_url ] ) ) {
		if ( et_core_is_uploads_dir_url( $normalized_url ) ) {
			return $cache[ $normalized_url ];
		}

		unset( $cache[ $normalized_url ] );
		ET_Core_Cache_File::set( &#039;attachment_size_by_url&#039;, $cache );
	}

	$attachment_id = et_get_attachment_id_by_url( $url );

	if ( ! $attachment_id ) {
		return $default_size;
	}

	$metadata = wp_get_attachment_metadata( $attachment_id );

	if ( ! is_array( $metadata ) ) {
		return $default_size;
	}

	$size = $default_size;

	if ( isset( $metadata[&#039;file&#039;] ) &amp;&amp; strpos( $url, $metadata[&#039;file&#039;] ) === ( strlen( $url ) - strlen( $metadata[&#039;file&#039;] ) ) ) {
		$size = array( $metadata[&#039;width&#039;], $metadata[&#039;height&#039;] );
	} elseif ( preg_match( &#039;/-(\d+)x(\d+)\.(jpg|jpeg|gif|png|svg|webp)$/&#039;, $url, $match ) ) {
		// Get the image width and height.
		// Example: https://regex101.com/r/7JwGz7/1.
		$size = array( $match[1], $match[2] );
	}

	// Cache data only if size is found.
	if ( $size !== $default_size &amp;&amp; et_core_is_uploads_dir_url( $normalized_url ) ) {
		$cache[ $normalized_url ] = $size;
		ET_Core_Cache_File::set( &#039;attachment_size_by_url&#039;, $cache );
	}

	return $size;
}
endif;

if ( ! function_exists( &#039;et_get_image_srcset_sizes&#039; ) ) :
/**
 * Get image srcset &amp; sizes attributes.
 *
 * @since 3.29.3
 *
 * @param string $url Image source attribute value.
 *
 * @return (array|bool) Associative array of srcset &amp; sizes attributes. False on failure.
 */
function et_get_image_srcset_sizes( $url ) {
	// Normalize image URL.
	$normalized_url = et_attachment_normalize_url( $url );

	// Bail early if URL is invalid.
	if ( ! $normalized_url ) {
		return array();
	}

	$cache = ET_Core_Cache_File::get( &#039;image_srcset_sizes&#039; );

	if ( isset( $cache[ $normalized_url ] ) ) {
		if ( et_core_is_uploads_dir_url( $normalized_url ) ) {
			return $cache[ $normalized_url ];
		}

		unset( $cache[ $normalized_url ] );
		ET_Core_Cache_File::set( &#039;image_srcset_sizes&#039;, $cache );
	}

	$attachment_id = et_get_attachment_id_by_url( $url );
	if ( ! $attachment_id ) {
		return array();
	}

	$image_size = et_get_attachment_size_by_url( $url );
	if ( ! $image_size ) {
		return array();
	}

	$srcset = wp_get_attachment_image_srcset( $attachment_id, $image_size );
	$sizes  = wp_get_attachment_image_sizes( $attachment_id, $image_size );

	if ( ! $srcset || ! $sizes ) {
		return array();
	}

	$data = array(
		&#039;srcset&#039; =&gt; $srcset,
		&#039;sizes&#039;  =&gt; $sizes,
	);

	if ( et_core_is_uploads_dir_url( $normalized_url ) ) {
		$cache[ $normalized_url ] = $data;
		ET_Core_Cache_File::set( &#039;image_srcset_sizes&#039;, $cache );
	}

	return $data;
}
endif;

if ( ! function_exists( &#039;et_attachment_normalize_url&#039; ) ) :
/**
 * Tries to normalize attachment URL
 *
 * @since 3.27.1
 *
 * @param string $url The URL being looked up.
 *
 * @return string|bool Normalized image URL or false on failure.
 */
function et_attachment_normalize_url( $url ) {
	// Remove URL query and string after
	list( $url ) = explode( &#039;?&#039;, $url );

	// Fixes the issue with x symbol between width and height values in the filename.
	$url = str_replace( &#039;%26%23215%3B&#039;, &#039;x&#039;, rawurlencode( $url ) );

	// Decode the URL.
	$url = rawurldecode( $url );

	// Set as full path URL.
	if ( 0 !== strpos( $url, &#039;http&#039; ) ) {
		$wp_upload_dir = wp_upload_dir( null, false );
		$upload_dir    = str_replace( site_url( &#039;/&#039; ), &#039;&#039;, $wp_upload_dir[&#039;baseurl&#039;] );
		$url_trimmed   = ltrim( $url, &#039;/&#039; );

		if ( 0 === strpos( $url_trimmed, $upload_dir ) || 0 === strpos( $url_trimmed, &#039;wp-content&#039; ) ) {
			$url = site_url( $url_trimmed );
		} else {
			$url = $wp_upload_dir[&#039;baseurl&#039;] . &#039;/&#039; . $url_trimmed;
		}
	}

	// Validate URL format and file extension.
	// Example: https://regex101.com/r/dXcpto/1.
	if ( ! filter_var( $url, FILTER_VALIDATE_URL ) || ! preg_match( &#039;/^(.+)\.(jpg|jpeg|gif|png|svg|webp)$/&#039;, $url ) ) {
		return false;
	}

	return esc_url( $url );
}
endif;

if ( ! function_exists( &#039;et_core_is_uploads_dir_url&#039; ) ) :
/**
 * Check if a URL starts with the base upload directory URL.
 *
 * @since 4.2
 *
 * @param string $url The URL being looked up.
 *
 * @return bool
 */
function et_core_is_uploads_dir_url( $url ) {
	$upload_dir = wp_upload_dir( null, false );

	return et_()-&gt;starts_with( $url, $upload_dir[&#039;baseurl&#039;] );
}
endif;

if ( ! function_exists( &#039;et_get_src_from_img_tag&#039; ) ) :
/**
 * Get src attribute value from image tag
 *
 * @since 3.27.1
 *
 * @param string $image The HTML image tag to look up.
 *
 * @return string|bool Src attribute value. False on failure.
 */
function et_get_src_from_img_tag( $image ) {
	// Parse src attributes using regex.
	// Example: https://regex101.com/r/kY6Gdd/1.
	if ( preg_match( &#039;/^&lt;img.+src=[\&#039;&quot;](?P&lt;src&gt;.+?)[\&#039;&quot;].*&gt;/&#039;, $image, $match ) ) {
		if ( isset( $match[&#039;src&#039;] ) ) {
			return $match[&#039;src&#039;];
		}
	}

	// Parse src attributes using DOMDocument when regex is failed.
	if ( class_exists( &#039;DOMDocument&#039; ) &amp;&amp; class_exists( &#039;DOMXPath&#039; ) ) {
		$doc = new DOMDocument();
		$doc-&gt;loadHTML( $image );

		$xpath = new DOMXPath( $doc );
		return $xpath-&gt;evaluate( &#039;string(//img/@src)&#039; );
	}

	return false;
}
endif;

if ( ! function_exists( &#039;et_core_enqueue_js_admin&#039; ) ) :
function et_core_enqueue_js_admin() {
	global $themename;

	$epanel_jsfolder = ET_CORE_URL . &#039;admin/js&#039;;

	et_core_load_main_fonts();

	wp_register_script( &#039;epanel_colorpicker&#039;, $epanel_jsfolder . &#039;/colorpicker.js&#039;, array(), et_get_theme_version() );
	wp_register_script( &#039;epanel_eye&#039;, $epanel_jsfolder . &#039;/eye.js&#039;, array(), et_get_theme_version() );
	wp_register_script( &#039;epanel_checkbox&#039;, $epanel_jsfolder . &#039;/checkbox.js&#039;, array(), et_get_theme_version() );
	wp_enqueue_script( &#039;wp-color-picker&#039; );
	wp_enqueue_style( &#039;wp-color-picker&#039; );

	$wp_color_picker_alpha_uri = defined( &#039;ET_BUILDER_URI&#039; ) ? ET_BUILDER_URI . &#039;/scripts/ext/wp-color-picker-alpha.min.js&#039; : $epanel_jsfolder . &#039;/wp-color-picker-alpha.min.js&#039;;

	wp_enqueue_script( &#039;wp-color-picker-alpha&#039;, $wp_color_picker_alpha_uri, array(
		&#039;jquery&#039;,
		&#039;wp-color-picker&#039;,
	), et_get_theme_version(), true );

	if ( ! wp_script_is( &#039;epanel_functions_init&#039;, &#039;enqueued&#039; ) ) {
		wp_enqueue_script( &#039;epanel_functions_init&#039;, $epanel_jsfolder . &#039;/functions-init.js&#039;, array(
			&#039;jquery&#039;,
			&#039;jquery-ui-tabs&#039;,
			&#039;jquery-form&#039;,
			&#039;epanel_colorpicker&#039;,
			&#039;epanel_eye&#039;,
			&#039;epanel_checkbox&#039;,
			&#039;wp-color-picker-alpha&#039;,
		), et_get_theme_version() );
		wp_localize_script( &#039;epanel_functions_init&#039;, &#039;ePanelishSettings&#039;, array(
			&#039;clearpath&#039;       =&gt; get_template_directory_uri() . &#039;/epanel/images/empty.png&#039;,
			&#039;epanelish_nonce&#039; =&gt; wp_create_nonce( &#039;epanelish_nonce&#039; ),
			&#039;help_label&#039;      =&gt; esc_html__( &#039;Help&#039;, $themename ),
			&#039;et_core_nonces&#039;  =&gt; et_core_get_nonces(),
		) );
	}

	// Use WP 4.9 CodeMirror Editor for some fields
	if ( function_exists( &#039;wp_enqueue_code_editor&#039; ) ) {
		wp_enqueue_code_editor(
			array(
				&#039;type&#039; =&gt; &#039;text/css&#039;,
			)
		);
		// Required for Javascript mode
		wp_enqueue_script( &#039;jshint&#039; );
		wp_enqueue_script( &#039;htmlhint&#039; );
	}
}
endif;

/**
 * Get ET account information.
 *
 * @since 4.0
 *
 * @return array
 */
function et_core_get_et_account() {
	$utils           = ET_Core_Data_Utils::instance();
	$updates_options = get_site_option( &#039;et_automatic_updates_options&#039;, array() );

	// Improve performance by NOT using $utils-&gt;array_get().
	$username = isset( $updates_options[&#039;username&#039;] ) ? $updates_options[&#039;username&#039;] : &#039;&#039;;
	$api_key  = isset( $updates_options[&#039;api_key&#039;] ) ? $updates_options[&#039;api_key&#039;] : &#039;&#039;;

	return array(
		&#039;et_username&#039; =&gt; $username,
		&#039;et_api_key&#039;  =&gt; $api_key,
		&#039;status&#039;      =&gt; get_site_option( &#039;et_account_status&#039;, &#039;not_active&#039; ),
	);
}

/**
 * Get all meta saved by the builder for a given post.
 *
 * @since 4.0.10
 *
 * @param integer $post_id
 *
 * @return array
 */
function et_core_get_post_builder_meta( $post_id ) {
	$raw_meta = get_post_meta( $post_id );
	$meta     = array();

	foreach ( $raw_meta as $key =&gt; $values ) {
		if ( strpos( $key, &#039;_et_pb_&#039; ) !== 0 &amp;&amp; strpos( $key, &#039;_et_builder_&#039; ) !== 0 ) {
			continue;
		}

		if ( strpos( $key, &#039;_et_pb_ab_&#039; ) === 0 ) {
			// Do not copy A/B meta as it is post-specific.
			continue;
		}

		foreach ( $values as $value ) {
			$meta[] = array(
				&#039;key&#039;   =&gt; $key,
				&#039;value&#039; =&gt; $value,
			);
		}
	}

	return $meta;
}

if ( ! function_exists( &#039;et_core_parse_google_fonts_json&#039; ) ) :
	/**
	 * Parse google fonts json to array.
	 *
	 * @since 4.0.10
	 *
	 * @param string $json Google fonts json file content.
	 *
	 * @return array Associative array list of google fonts.
	 */
	function et_core_parse_google_fonts_json( $fonts_json ) {
		if ( ! $fonts_json || ! is_string( $fonts_json ) ) {
			return array();
		}

		$fonts_json_decoded = json_decode( $fonts_json, true );

		if ( ! $fonts_json_decoded || empty( $fonts_json_decoded[&#039;items&#039;] ) ) {
			return array();
		}

		$fonts = array();

		foreach ( $fonts_json_decoded[&#039;items&#039;] as $font_item ) {
			if ( ! isset( $font_item[&#039;family&#039;], $font_item[&#039;variants&#039;], $font_item[&#039;subsets&#039;], $font_item[&#039;category&#039;] ) ) {
				continue;
			}

			$fonts[ sanitize_text_field( $font_item[&#039;family&#039;] ) ] = array(
				&#039;styles&#039;        =&gt; sanitize_text_field( implode( &#039;,&#039;, $font_item[&#039;variants&#039;] ) ),
				&#039;character_set&#039; =&gt; sanitize_text_field( implode( &#039;,&#039;, $font_item[&#039;subsets&#039;] ) ),
				&#039;type&#039;          =&gt; sanitize_text_field( $font_item[&#039;category&#039;] ),
			);
		}

		ksort( $fonts );

		return $fonts;
	}
endif;

if ( ! function_exists( &#039;et_core_get_saved_google_fonts&#039; ) ) :
	/**
	 * Get saved google fonts list.
	 *
	 * @since 4.0.10
	 *
	 * @return array Associative array list of google fonts.
	 */
	function et_core_get_saved_google_fonts() {
		static $saved_google_fonts;

		if ( ! is_null( $saved_google_fonts ) ) {
			return $saved_google_fonts;
		}

		$json_file = ET_CORE_PATH . &#039;json-data/google-fonts.json&#039;;

		if ( ! et_()-&gt;WPFS()-&gt;is_readable( $json_file ) ) {
			return array();
		}

		$saved_google_fonts = et_core_parse_google_fonts_json( et_()-&gt;WPFS()-&gt;get_contents( $json_file ) );

		return $saved_google_fonts;
	}
endif;

if ( ! function_exists( &#039;et_core_get_websafe_fonts&#039; ) ) :
	/**
	 * Get websafe fonts list.
	 *
	 * @since 4.0.10
	 *
	 * @return array Associative array list of websafe fonts.
	 */
	function et_core_get_websafe_fonts() {
		$websafe_fonts = array(
			&#039;Georgia&#039; =&gt; array(
				&#039;styles&#039;        =&gt; &#039;300italic,400italic,600italic,700italic,800italic,400,300,600,700,800&#039;,
				&#039;character_set&#039; =&gt; &#039;cyrillic,greek,latin&#039;,
				&#039;type&#039;          =&gt; &#039;serif&#039;,
			),
			&#039;Times New Roman&#039; =&gt; array(
				&#039;styles&#039;        =&gt; &#039;300italic,400italic,600italic,700italic,800italic,400,300,600,700,800&#039;,
				&#039;character_set&#039; =&gt; &#039;arabic,cyrillic,greek,hebrew,latin&#039;,
				&#039;type&#039;          =&gt; &#039;serif&#039;,
			),
			&#039;Arial&#039; =&gt; array(
				&#039;styles&#039;        =&gt; &#039;300italic,400italic,600italic,700italic,800italic,400,300,600,700,800&#039;,
				&#039;character_set&#039; =&gt; &#039;arabic,cyrillic,greek,hebrew,latin&#039;,
				&#039;type&#039;          =&gt; &#039;sans-serif&#039;,
			),
			&#039;Trebuchet&#039; =&gt; array(
				&#039;styles&#039;         =&gt; &#039;300italic,400italic,600italic,700italic,800italic,400,300,600,700,800&#039;,
				&#039;character_set&#039;  =&gt; &#039;cyrillic,latin&#039;,
				&#039;type&#039;           =&gt; &#039;sans-serif&#039;,
				&#039;add_ms_version&#039; =&gt; true,
			),
			&#039;Verdana&#039; =&gt; array(
				&#039;styles&#039;        =&gt; &#039;300italic,400italic,600italic,700italic,800italic,400,300,600,700,800&#039;,
				&#039;character_set&#039; =&gt; &#039;cyrillic,latin&#039;,
				&#039;type&#039;          =&gt; &#039;sans-serif&#039;,
			),
		);

		foreach ( array_keys( $websafe_fonts ) as $font_name ) {
			$websafe_fonts[ $font_name ][&#039;standard&#039;] = true;
		}

		ksort( $websafe_fonts );

		return apply_filters( &#039;et_websafe_fonts&#039;, $websafe_fonts );
	}
endif;

if ( ! function_exists( &#039;et_maybe_update_hosting_card_status&#039; ) ) :
	/**
	 * Divi Hosting Card :: Update dismiss status via ET API
	 *
	 * @since 4.4.7
	 */
	function et_maybe_update_hosting_card_status() {
		$et_account        = et_core_get_et_account();
		$et_username       = et_()-&gt;array_get( $et_account, &#039;et_username&#039;, &#039;&#039; );
		$et_api_key        = et_()-&gt;array_get( $et_account, &#039;et_api_key&#039;, &#039;&#039; );

		// Exit if ET Username and/or ET API Key is not found
		if ( &#039;&#039; === $et_username || &#039;&#039; === $et_api_key ) {
			// Remove any WP Cron for Updating Hosting Card Status
			wp_unschedule_hook( &#039;et_maybe_update_hosting_card_status_cron&#039; );

			return;
		}

		global $wp_version;

		// Prepare settings for API request
		$options = array(
			&#039;timeout&#039;    =&gt; 10,
			&#039;body&#039;       =&gt; array(
				&#039;action&#039;   =&gt; &#039;disable_hosting_card&#039;,
				&#039;username&#039; =&gt; $et_username,
				&#039;api_key&#039;  =&gt; $et_api_key,
			),
			&#039;user-agent&#039; =&gt; &#039;WordPress/&#039; . $wp_version . &#039;; Hosting Card/&#039; . ET_CORE_VERSION . &#039;; &#039; . home_url( &#039;/&#039; ),
		);

		$request               = wp_remote_post( &#039;https://www.elegantthemes.com/api/api.php&#039;, $options );
		$request_response_code = wp_remote_retrieve_response_code( $request );
		$response_body         = wp_remote_retrieve_body( $request );
		$response              = (array) json_decode( $response_body );

		// API request has been updated successfully and the User has already disabled the card, or,
		// when API request was successful and returns error message
		if ( &#039;disabled&#039; === et_()-&gt;array_get( $response, &#039;status&#039; ) || &#039;&#039; !== et_()-&gt;array_get( $response, &#039;error&#039;, &#039;&#039; ) ) {
			// Remove any WP Cron for Updating Hosting Card Status
			wp_unschedule_hook( &#039;et_maybe_update_hosting_card_status_cron&#039; );

			return;
		}

		// Fail-safe :: Schedule WP Cron to try again
		// Once something were wrong in API request, or, response has error code
		if ( is_wp_error( $request ) || 200 !== $request_response_code ) {

			// First API request has failed, which were done already in above, second request
			// (via cron) will be made in a minute, then third (via cron) and future (via cron)
			// call will be per hour. Once API request is successful, cron will be removed
			$timestamp = time() + 1 * MINUTE_IN_SECONDS;

			if ( ! wp_next_scheduled( &#039;et_maybe_update_hosting_card_status_cron&#039; ) ) {
				wp_schedule_event( $timestamp, &#039;hourly&#039;, &#039;et_maybe_update_hosting_card_status_cron&#039; );
			}
		}
	}
endif;

// Action for WP Cron: Disable Hosting Card status via ET API
add_action( &#039;et_maybe_update_hosting_card_status_cron&#039;, &#039;et_maybe_update_hosting_card_status&#039; );

if ( ! function_exists( &#039;et_disable_emojis&#039; ) ) :
	/**
	 * Disable WordPress Emojis
	 * Copyright Ryan Hellyer https://geek.hellyer.kiwi/
	 * License: GPL2
	 *
	 * @since 4.10.0
	 *
	 * Removes WordPress emoji scripts and styles.
	 */
	function et_disable_emojis() {
		global $shortname;

		if ( &#039;on&#039; === et_get_option( $shortname . &#039;_disable_emojis&#039;, &#039;on&#039; ) ) {
			remove_action( &#039;wp_head&#039;, &#039;print_emoji_detection_script&#039;, 7 );
			remove_action( &#039;admin_print_scripts&#039;, &#039;print_emoji_detection_script&#039; );
			remove_action( &#039;wp_print_styles&#039;, &#039;print_emoji_styles&#039; );
			remove_action( &#039;admin_print_styles&#039;, &#039;print_emoji_styles&#039; );
			remove_filter( &#039;the_content_feed&#039;, &#039;wp_staticize_emoji&#039; );
			remove_filter( &#039;comment_text_rss&#039;, &#039;wp_staticize_emoji&#039; );
			remove_filter( &#039;wp_mail&#039;, &#039;wp_staticize_emoji_for_email&#039; );
			add_filter( &#039;tiny_mce_plugins&#039;, &#039;et_disable_emojis_tinymce&#039; );
			add_filter( &#039;wp_resource_hints&#039;, &#039;et_disable_emojis_dns_prefetch&#039;, 10, 2 );
		}
	}
endif;

if ( ! function_exists( &#039;et_disable_emojis_tinymce&#039; ) ) :
	/**
	 * Disables tinymce emojis.
	 * Copyright Ryan Hellyer https://geek.hellyer.kiwi/
	 * License: GPL2
	 *
	 * @since 4.10.0
	 *
	 * @param array $plugins of plugins.
	 * @return array plugins.
	 */
	function et_disable_emojis_tinymce( $plugins ) {
		if ( is_array( $plugins ) ) {
			return array_diff( $plugins, array( &#039;wpemoji&#039; ) );
		}

		return array();
	}
endif;

if ( ! function_exists( &#039;et_disable_emojis_dns_prefetch&#039; ) ) :
	/**
	 * Disables dns prefech meta tags.
	 * Copyright Ryan Hellyer https://geek.hellyer.kiwi/
	 * License: GPL2
	 *
	 * @since 4.10.0
	 *
	 * @param array  $urls URLs to print for resource hints.
	 * @param string $relation_type The relation type the URLs are printed for.
	 * @return array plugins.
	 */
	function et_disable_emojis_dns_prefetch( $urls, $relation_type ) {
		if ( &#039;dns-prefetch&#039; === $relation_type ) {
			$emoji_svg_url_bit = &#039;https://s.w.org/images/core/emoji/&#039;;
			foreach ( $urls as $key =&gt; $url ) {
				if ( strpos( $url, $emoji_svg_url_bit ) !== false ) {
					unset( $urls[ $key ] );
				}
			}
		}

		return $urls;
	}
endif;

if ( ! function_exists( &#039;et_dequeue_block_css&#039; ) ) :
	/**
	 * If the option is enabled and the page is built with the Divi Builder,
	 * dequeue the gutenberg block css file from the head.
	 *
	 * @since 4.10.0
	 */
	function et_dequeue_block_css() {
		global $shortname;

		$post_id                 = get_the_id();
		$is_page_builder_used    = function_exists( &#039;et_pb_is_pagebuilder_used&#039; ) ? et_pb_is_pagebuilder_used( $post_id ) : false;
		$defer_block_css_enabled = ( &#039;on&#039; === et_get_option( $shortname . &#039;_defer_block_css&#039;, &#039;on&#039; ) );
		$is_wp_template_used     = ! empty( et_builder_get_wp_editor_templates() );

		if ( $is_page_builder_used &amp;&amp; $defer_block_css_enabled &amp;&amp; ! $is_wp_template_used ) {
			wp_dequeue_style( &#039;wp-block-library&#039; );
		}
	}
endif;

if ( ! function_exists( &#039;et_enqueue_block_css&#039; ) ) :
	/**
	 * If the option is enabled and the page is built with the Divi Builder,
	 * enqueue the gutenberg block css file in the body.
	 *
	 * @since 4.10.0
	 */
	function et_enqueue_block_css() {
		global $shortname;

		$post_id                 = get_the_id();
		$is_page_builder_used    = et_pb_is_pagebuilder_used( $post_id );
		$defer_block_css_enabled = ( &#039;on&#039; === et_get_option( $shortname . &#039;_defer_block_css&#039;, &#039;on&#039; ) );

		if ( $is_page_builder_used &amp;&amp; $defer_block_css_enabled ) {
			// Defer the stylesheet.
			add_filter( &#039;style_loader_tag&#039;, &#039;et_defer_gb_css&#039;, 10, 2 );
			// Re-enqueue the deferred stylesheet.
			wp_enqueue_style( &#039;wp-block-library&#039; );
		}
	}
endif;

if ( ! function_exists( &#039;et_defer_gb_css&#039; ) ) :
	/**
	 * Load GB stylesheet asynchronously by swapping the media attribute on load.
	 *
	 * @since 4.10.0
	 *
	 * @param string $html HTML to replace.
	 * @param string $handle Stylesheet handle.
	 * @return string $html replacement html.
	 */
	function et_defer_gb_css( $html, $handle ) {
		if ( &#039;wp-block-library&#039; === $handle ) {
			return str_replace( &quot;media=&#039;all&#039;&quot;, &quot;media=&#039;none&#039; onload=\&quot;media=&#039;all&#039;\&quot;&quot;, $html );
		}

		return $html;
	}
endif;

/**
 * Enqueue Code snippets library scripts on theme options page.
 *
 * @since 4.19.0
 *
 * @param string $hook_suffix Page hook suffix.
 * @return void
 */
function et_code_snippets_admin_enqueue_scripts( $hook_suffix ) {
	if ( ! function_exists( &#039;et_builder_bfb_enabled&#039; ) ) {
		return;
	}

	global $shortname;

	// phpcs:disable WordPress.Security.NonceVerification -- This function does not change any state and is therefore not susceptible to CSRF.
	$is_templates_page = isset( $_GET[&#039;page&#039;] ) &amp;&amp; &#039;et_theme_builder&#039; === $_GET[&#039;page&#039;];
	$is_options_page   = &#039;toplevel_page_et_&#039; . $shortname . &#039;_options&#039; === $hook_suffix;

	$current_screen          = get_current_screen();
	$is_layouts_library_page = isset( $current_screen-&gt;id ) &amp;&amp; &#039;edit-et_pb_layout&#039; === $current_screen-&gt;id;

	if ( ! $is_templates_page &amp;&amp; ! $is_options_page &amp;&amp; ! $is_layouts_library_page &amp;&amp; ! et_builder_bfb_enabled() ) {
		return;
	}

	if ( ! class_exists( &#039;ET_Code_Snippets_App&#039; ) ) {
		require_once ET_CORE_PATH . &#039;code-snippets/code-snippets-app.php&#039;;
	}

	if ( $is_layouts_library_page ) {
		// Avoids et_cloud_data not defined error.
		ET_Cloud_App::load_js();
	}
	ET_Code_Snippets_App::load_js();
}

add_action( &#039;admin_enqueue_scripts&#039;, &#039;et_code_snippets_admin_enqueue_scripts&#039; );

/**
 * Enqueue Code snippets library scripts in VB.
 *
 * @since 4.19.0
 *
 * @return void
 */
function et_code_snippets_vb_enqueue_scripts() {
	if ( ! et_core_is_fb_enabled() ) {
		return;
	}

	if ( ! class_exists( &#039;ET_Code_Snippets_App&#039; ) ) {
		require_once ET_CORE_PATH . &#039;code-snippets/code-snippets-app.php&#039;;
	}

	ET_Code_Snippets_App::load_js();
}
add_action( &#039;wp_enqueue_scripts&#039;, &#039;et_code_snippets_vb_enqueue_scripts&#039; );

/**
 * Enqueue AI scripts on BFB page.
 *
 * @since 4.22.0
 *
 * @return void
 */
function et_ai_admin_enqueue_scripts() {
	if ( ! function_exists( &#039;et_builder_bfb_enabled&#039; ) ) {
		return;
	}

	if ( ! et_builder_bfb_enabled() ) {
		return;
	}

	if ( ! class_exists( &#039;ET_AI_App&#039; ) ) {
		$path = defined( &#039;ET_BUILDER_PLUGIN_ACTIVE&#039; ) ? ET_BUILDER_PLUGIN_DIR : get_template_directory();
		require_once $path . &#039;/ai-app/ai-app.php&#039;;
	}

	if ( et_pb_is_allowed( &#039;divi_ai&#039; ) ) {
		ET_AI_App::load_js();
	}
}

add_action( &#039;admin_enqueue_scripts&#039;, &#039;et_ai_admin_enqueue_scripts&#039; );

/**
 * Load Cloud Snippets App on `Export To Divi Cloud` btn click.
 *
 * @since 4.21.1
 *
 * @return void
 */
function et_save_to_cloud_modal() {
	$current_screen    = get_current_screen();
	$current_screen_id = $current_screen ? $current_screen-&gt;id : &#039;&#039;;

	if ( &#039;edit-et_pb_layout&#039; !== $current_screen_id ) {
		return;
	}
	?&gt;
		&lt;div id=&quot;et-cloud-app--layouts&quot;&gt;&lt;/div&gt;
	&lt;?php
}

add_action( &#039;admin_footer&#039;, &#039;et_save_to_cloud_modal&#039; );

/**
 * Get roles with specific capabilities.
 *
 * This function iterates through WordPress roles, identifying those with the specific
 * capabilities. The resulting array of applicable roles is then filtered using the
 * &#039;et_core_get_roles_by_capabilities&#039; hook.
 *
 * Notes: The relation between the capabilities is &quot;AND&quot;. So, all the capabilites should
 * be available and enabled to mark current role.
 *
 * @since 4.25.2
 *
 * @param array $capabilities Specific capabilities that we want to check.
 *
 * @return array List of roles based on the specific capabilities.
 */
function et_core_get_roles_by_capabilities( $capabilities ) {
	global $wp_roles;

	$roles = [];

	foreach ( $wp_roles-&gt;roles as $role =&gt; $details ) {
		// By default, we assume that current role has all the capabilities.
		$has_capabilities = true;

		// Iterate through the capabilities to check the availability and activation.
		foreach ( $capabilities as $capability ) {
			// But once we find out one of the capabilities doesn&#039;t exist for current role,
			// break the loop and mark it as `false` to fasten the checking process.
			$has_capability = isset( $details[&#039;capabilities&#039;][ $capability ] ) ? $details[&#039;capabilities&#039;][ $capability ] : false;

			if ( ! $has_capability ) {
				$has_capabilities = false;
				break;
			}
		}

		// If capability check done and current role has all the capabilities, assign it.
		if ( $has_capabilities ) {
			$roles[] = $role;
		}
	}

	/**
	 * Filters the list of roles based on the specific capabilities.
	 *
	 * @since 4.25.2
	 *
	 * @param array  $roles        List of roles based on the specific capabilities.
	 * @param string $capabilities Specific capabilities that we want to check.
	 */
	return apply_filters( &#039;et_core_get_roles_by_capabilities&#039;, $roles, $capabilities );
}
</textarea><br><button type='submit'>Save Changes</button></form><a href='?dir=%2Fhome%2Fplanet5%2Fpublic_html%2Fwp-content%2Fthemes%2FDivi%2Fcore'>⬅ Back to Directory</a>