<?php

if ( ! function_exists( 'et_allow_ampersand' ) ) :
/**
 * Convert &amp; into &
 * 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('&amp;', '&', $string);
}
endif;


if ( ! function_exists( 'et_core_autoloader' ) ):
/**
 * Callback for {@link spl_autoload_register()}.
 *
 * @param $class_name
 */
function et_core_autoloader( $class_name ) {
	if ( 0 !== strpos( $class_name, 'ET_Core' ) ) {
		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 ]['file'];
	$groups = $components[ $class_name ]['groups'];
	$slug   = $components[ $class_name ]['slug'];

	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( "et_core_component_{$slug}_loaded" );

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

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

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

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

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


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

	$schedules['monthly'] = array(
		'interval' => MONTH_IN_SECONDS,
		'display'  => __( 'Once Monthly' )
	);

	return $schedules;
}
add_action( 'cron_schedules', 'et_core_cron_schedules_cb' );
endif;


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

	wp_die();
}
endif;


if ( ! function_exists( 'et_core_get_components_metadata' ) ):
function et_core_get_components_metadata() {
	static $metadata = null;

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

	return $metadata;
}
endif;


if ( ! function_exists( 'et_core_get_component_names' ) ):
/**
 * 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 'official'.
 * @param string $group   Only include components in $group. Optional.
 *
 * @return array
 */
function et_core_get_component_names( $include = 'official', $group = '' ) {
	static $official_components = null;

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

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

	$third_party_components = et_core_get_third_party_components();

	if ( 'third-party' === $include ) {
		return array_keys( $third_party_components );
	}

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


if ( ! function_exists( 'et_core_get_ip_address' ) ):
/**
 * 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(
		'HTTP_TRUE_CLIENT_IP',
		'HTTP_CF_CONNECTING_IP',
		'HTTP_X_SUCURI_CLIENTIP',
		'HTTP_X_FORWARDED_FOR',
		'HTTP_X_FORWARDED',
		'HTTP_X_CLUSTER_CLIENT_IP',
		'HTTP_FORWARDED_FOR',
		'HTTP_FORWARDED',
		'HTTP_CLIENT_IP',
		'REMOTE_ADDR',
	);

	$ip = '';

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

		$header = $_SERVER[ $header ];

		if ( et_()->includes( $header, ',' ) ) {
			$header = explode( ',', $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( 'et_core_use_google_fonts' ) ) :
function et_core_use_google_fonts() {
	$utils              = ET_Core_Data_Utils::instance();
	$google_api_options = get_option( 'et_google_api_settings' );

	return 'on' === $utils->array_get( $google_api_options, 'use_google_fonts', 'on' );
}
endif;

if ( ! function_exists( 'et_core_get_main_fonts' ) ) :
function et_core_get_main_fonts() {
	global $wp_version;

	if ( version_compare( $wp_version, '4.6', '<' ) || ( ! is_admin() && ! et_core_use_google_fonts() ) ) {
		return '';
	}

	$fonts_url = '';

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

	if ( 'off' !== $open_sans ) {
		$font_families = array();

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

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

	return $fonts_url;
}
endif;


if ( ! function_exists( 'et_core_get_theme_info' ) ):
function et_core_get_theme_info( $key ) {
	static $theme_info = null;

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

		if ( defined( 'STYLESHEETPATH' ) && is_child_theme() ) {
			$theme_info = wp_get_theme( $theme_info->parent_theme );
		}
	}

	return $theme_info->display( $key );
}
endif;


if ( ! function_exists( 'et_core_get_third_party_components' ) ):
function et_core_get_third_party_components( $group = '' ) {
	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'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( 'et_core_get_third_party_components', array(), $group );
}
endif;


if ( ! function_exists( 'et_core_get_memory_limit' ) ):
/**
 * 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( 'memory_limit' );
	$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( 'et_core_initialize_component_group' ) ):
function et_core_initialize_component_group( $slug, $init_file = null ) {
	$slug = strtolower( $slug );

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

		$init = "et_core_{$slug}_init";

		$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( "et_core_{$slug}_loaded" );
}
endif;


if ( ! function_exists( 'et_core_is_builder_used_on_current_request' ) ) :
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( 'Called too early! $wp_query is not available.' );
		return false;
	}

	$builder_used = false;

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

	return $builder_used = apply_filters( 'et_core_is_builder_used_on_current_request', $builder_used );
}
endif;


if ( ! function_exists( 'et_core_is_fb_enabled' ) ):
function et_core_is_fb_enabled() {
	if ( function_exists( 'et_fb_is_enabled' ) ) {
		return et_fb_is_enabled();
	}

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

if ( ! function_exists( 'et_core_is_saving_builder_modules_cache' ) ):
function et_core_is_saving_builder_modules_cache() {
	// This filter is set when Modules Cache is being saved.
	return apply_filters( 'et_builder_modules_is_saving_cache', 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( 'et_core_is_gutenberg_active' ) ):
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, '5.0-alpha1', '>=' );
	}

	return $has_wp5_plus || function_exists( 'is_gutenberg_page' );
}
endif;


/**
 * Is Gutenberg active and enabled for the current post
 * WP 5.0 WARNING - don'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( 'et_core_is_gutenberg_enabled' ) ):
function et_core_is_gutenberg_enabled() {
	if ( function_exists( 'is_gutenberg_page' ) ) {
		return et_core_is_gutenberg_active() && is_gutenberg_page() && has_filter( 'replace_editor', 'gutenberg_init' );
	}

	return et_core_is_gutenberg_active() && function_exists( 'use_block_editor_for_post' ) && use_block_editor_for_post( null );
}
endif;


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

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


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

	wp_enqueue_style( 'et-core-admin' );
}
endif;


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

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

	update_option( 'et_core_version', ET_CORE_VERSION );

	define( 'ET_CORE_UPDATED', true );
}
endif;


if ( ! function_exists( 'et_core_maybe_patch_old_theme' ) ):
function et_core_maybe_patch_old_theme() {
	if ( ! ET_Core_Logger::php_notices_enabled() ) {
		return;
	}

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

	$themes         = array( 'Divi' => '3.0.41', 'Extra' => '2.0.40' );
	$current_theme  = et_core_get_theme_info( 'Name' );

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

	$theme_version = et_core_get_theme_info( 'Version' );

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


if ( ! function_exists( 'et_core_patch_core_3061' ) ):
function et_core_patch_core_3061() {
	if ( '3.0.61' !== 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 . 'init.php';
	$new_file = dirname( __FILE__ ) . '/init.php';

	ET_Core_PageResource::startup();

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

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


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

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

if ( ! function_exists( 'et_core_register_common_assets' ) ) :
/**
 * 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, & magnific js to avoid broken javascript on Facebook in-app browser
	wp_register_script( 'et-core-common', ET_CORE_URL . 'admin/js/common.js', array( 'jquery' ), ET_CORE_VERSION, true );
	wp_enqueue_script( 'et-core-common' );
}
endif;

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

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

	return $styles;
}
endif;
add_filter( 'gform_noconflict_styles', 'et_core_noconflict_scripts_gform' );

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

	return $scripts;
}
endif;
add_filter( 'gform_noconflict_scripts', 'et_core_noconflict_scripts_gform' );

if ( ! function_exists( 'et_core_security_check' ) ):
/**
 * Check if current user can perform an action and/or verify a nonce value. die() if not authorized.
 *
 * @examples:
 *   - Check if user can 'manage_options': `et_core_security_check();`
 *   - Verify a nonce value: `et_core_security_check( '', 'nonce_name' );`
 *   - Check if user can 'something' and verify a nonce value: `self::do_security_check( 'something', 'nonce_name' );`
 *
 * @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 '_nonce').
 * @param string $nonce_key      The key to use to lookup nonce value in `$nonce_location`. Default
 *                               is the value of `$nonce_action` with '_nonce' 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 = 'manage_options', $nonce_action = '', $nonce_key = '', $nonce_location = '_POST', $die = true ) {
	$user_can     = (string) $user_can;
	$nonce_action = (string) $nonce_action;
	$nonce_key    = (string) $nonce_key;

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

	// phpcs:disable WordPress.Security.NonceVerification.NoNonceVerification
	switch( $nonce_location ) {
		case '_POST':
			$nonce_location = $_POST;
			break;
		case '_GET':
			$nonce_location = $_GET;
			break;
		case '_REQUEST':
			$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 ( '' !== $nonce_action && empty( $nonce_location[ $nonce_key ] ) ) {
		// A nonce value is required when a nonce action is provided.
		$passed = false;

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

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

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

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

	return $passed;
}
endif;


if ( ! function_exists( 'et_core_security_check_passed' ) ):
/**
 * 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 = 'manage_options', $nonce_action = '', $nonce_key = '', $nonce_location = '_POST' ) {
	return et_core_security_check( $user_can, $nonce_action, $nonce_key, $nonce_location, false );
}
endif;


if ( ! function_exists( 'et_core_setup' ) ) :
/**
 * 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 = '' ) {
	if ( defined( 'ET_CORE_PATH' ) ) {
		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() . '/core/';
		$type = 'theme';
	} else {
		$url  = plugin_dir_url( __FILE__ );
		$type = 'plugin';
	}

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

	load_theme_textdomain( 'et-core', ET_CORE_PATH . 'languages/' );
	et_core_maybe_set_updated();
	et_new_core_setup();

	register_shutdown_function( 'ET_Core_PageResource::shutdown' );

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

	et_core_maybe_patch_old_theme();
}
endif;


if ( ! function_exists( 'et_force_edge_compatibility_mode' ) ) :
function et_force_edge_compatibility_mode() {
	echo '<meta http-equiv="X-UA-Compatible" content="IE=edge">';
}
endif;
add_action( 'et_head_meta', 'et_force_edge_compatibility_mode' );


if ( ! function_exists( 'et_get_allowed_localization_html_elements' ) ) :
function et_get_allowed_localization_html_elements() {
	$allowlisted_attributes = array(
		'id'    => array(),
		'class' => array(),
		'style' => array(),
	);

	$allowlisted_attributes = apply_filters( 'et_allowed_localization_html_attributes', $allowlisted_attributes );

	$elements = array(
		'a'      => array(
			'href'   => array(),
			'title'  => array(),
			'target' => array(),
			'rel'    => array(),
		),
		'b'      => array(),
		'br'     => array(),
		'em'     => array(),
		'p'      => array(),
		'span'   => array(),
		'div'    => array(),
		'strong' => array(),
		'code'   => array(),
	);

	$elements = apply_filters( 'et_allowed_localization_html_elements', $elements );

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

	return $elements;
}
endif;


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

if ( ! function_exists( 'et_get_theme_version' ) ) :
function et_get_theme_version() {
	$theme_info = wp_get_theme();

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

	$theme_version = $theme_info->display( 'Version' );

	return $theme_version;
}
endif;

if ( ! function_exists( 'et_get_child_theme_version' ) ) :
	/**
	 * 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->child_theme );
		$theme_version = $theme_info->display( 'Version' );

		return $theme_version;
	}
endif;

if ( ! function_exists( 'et_requeue_child_theme_styles' ) ) :
	/**
	 * 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(), '/' );
			$styles                 = wp_styles();
			$inline_style_suffix    = et_core_is_inline_stylesheet_enabled() && et_use_dynamic_css() ? '-inline' : '';
			$style_dep              = array( $shortname . '-style-parent' . $inline_style_suffix );

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

			foreach ( $styles->registered as $handle => $style ) {
				if ( preg_match( '/' . $template_directory_uri . '.*/', $style->src ) ) {
					et_core_replace_enqueued_style( $style->src, '', $theme_version, '', $style_dep, false );
				}
			}
		}
	}
endif;

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

	require_once ET_CORE_PATH . 'components/Updates.php';
	require_once ET_CORE_PATH . 'components/init.php';
	require_once ET_CORE_PATH . 'php_functions.php';
	require_once ET_CORE_PATH . 'wp_functions.php';

	if ( $has_php_52x ) {
		spl_autoload_register( 'et_core_autoloader', true );
	} else {
		spl_autoload_register( 'et_core_autoloader', true, true );
	}

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


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

	return sprintf( '<script src="%1$s" crossorigin></script>', esc_attr( $src ) ); // phpcs:ignore WordPress.WP.EnqueuedResources.NonEnqueuedScript
}
endif;


if ( ! function_exists( 'et_core_get_version_from_filesystem' ) ):
/**
 * 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 . '_et_core_version.php';

	if ( ! file_exists( $version_file ) ) {
		return '';
	}

	include $version_file;

	return $ET_CORE_VERSION;
}
endif;

if ( ! function_exists( 'et_core_replace_enqueued_style' ) ):
	/**
	 * Replace a style'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->registered ) ) {
			return;
		}

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

			if ( ! $match ) {
				continue;
			}

			$old_ver               = isset( $style->ver ) ? $style->ver : false;
			$old_handle            = $handle;
			$old_deps              = isset( $style->deps ) ? $style->deps : array();
			$style_handle          = $new_handle ? $new_handle : $old_handle;
			$style_src             = $regex ? preg_replace( $old_src, $new_src, $style->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->args ) ? $style->args : 'all';
			$inline_styles         = $styles->get_data( $handle, 'after' );
			$style_handle_filtered = apply_filters( 'et_core_enqueued_style_handle', $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( "\n", $inline_styles ) );
			}
		}
	}
endif;

if ( ! function_exists( 'et_core_is_inline_stylesheet_enabled' ) ) :
	/**
	 * 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( 'ET_BUILDER_PLUGIN_ACTIVE' ) ) {
			$options           = get_option( 'et_pb_builder_options', array() );
			$inline_stylesheet = isset( $options['performance_main_inline_stylesheet'] ) ? $options['performance_main_inline_stylesheet'] : 'on';
		} else {
			// Get option value. If Extra, defaults to off.
			$inline_stylesheet = et_get_option( $shortname . '_inline_stylesheet', 'extra' === $shortname ? 'off' : 'on' );
		}

		$enable_inline_stylesheet = 'on' === $inline_stylesheet ? true : false;

		return $enable_inline_stylesheet;
	}
endif;

if ( ! function_exists( 'et_core_is_safe_mode_active' ) ):
/**
 * Check whether the Support Center'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're checking against a particular product, return false if the product-specific usermeta doesn't match
	if ( $product ) {
		$product = esc_attr( $product );
		if ( $product === get_user_meta( get_current_user_id(), '_et_support_center_safe_mode_product', true ) ) {
			return true;
		}
		return false;
	};

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

if ( ! function_exists( 'et_core_load_component' ) ) :
/**
 * =============================
 * ----->>> DEPRECATED! <<<-----
 * =============================
 * 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['HTTP_USER_AGENT'] ) && false !== strpos( $_SERVER['HTTP_USER_AGENT'], 'Jetpack' );

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

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

	return $portability_loaded = true;
}
endif;


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

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

if ( ! function_exists( 'et_is_product_taxonomy' ) ):
/**
 * 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( 'is_product_taxonomy' ) && is_product_taxonomy();
}
endif;


if ( ! function_exists( 'et_core_add_allowed_protocols' ) ) :
/**
 * 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(
		'skype', // Add Skype messaging protocol
		'sms', // Add SMS text messaging protocol
	);
	$protocols  = array_unique( array_merge( $protocols, $additional ) );

	return $protocols;
}
add_filter( 'kses_allowed_protocols', 'et_core_add_allowed_protocols' );
endif;


if ( ! function_exists( 'et_is_responsive_images_enabled' ) ):
/**
 * 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( "{$shortname}_enable_responsive_images", 'on' );
	}

	return 'on' === $enable_responsive_images;
}
endif;

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

if ( ! function_exists( 'et_image_get_responsive_size' ) ) :
/**
 * Get images responsive sizes.
 *
 * @since 3.27.1
 *
 * @param int    $orig_width Original image's width.
 * @param int    $orig_height Original image's height.
 * @param string $breakpoint Screen breakpont. See et_screen_sizes().
 *
 * @return array|boolean Image responsive width & 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 >= $orig_width ) {
		return false;
	}

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

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

	return array(
		'width'  => $new_width,
		'height' => $new_height,
	);
}
endif;

if ( ! function_exists( 'et_image_add_srcset_and_sizes' ) ) :
/**
 * 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, 'html' );
		}

		return $image;
	}

	$src = et_get_src_from_img_tag( $image );

	$cache_key = $src ? $src : 'empty-src';

	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, 'html' );
	}

	return $image;
}
endif;

if ( ! function_exists( 'et_get_attachment_id_by_url_sql' ) ) :
	/**
	 * 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( '/^https?:/i', '', $normalized_url );

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

		if ( $cleaned_url === $fallback_url ) {
			$attachments_query = $wpdb->prepare(
				"SELECT id
				FROM $wpdb->posts
				WHERE `post_type` = %s
					AND `guid` IN ( %s, %s )",
				'attachment',
				esc_url_raw( "https:{$cleaned_url}" ),
				esc_url_raw( "http:{$cleaned_url}" )
			);
		} 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'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->prepare(
				"SELECT id
				FROM $wpdb->posts
				WHERE `post_type` = %s
					AND `guid` IN ( %s, %s, %s, %s )
				ORDER BY CHAR_LENGTH( `guid` ) DESC",
				'attachment',
				esc_url_raw( "https:{$cleaned_url}" ),
				esc_url_raw( "https:{$fallback_url}" ),
				esc_url_raw( "http:{$cleaned_url}" ),
				esc_url_raw( "http:{$fallback_url}" )
			);
		}

		return $attachments_query;
	}
endif;

if ( ! function_exists( 'et_get_attachment_id_by_url' ) ) :
/**
 * 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( 'et_get_attachment_id_by_url_pre', 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( 'et_get_attachment_id_by_url_guid', $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( 'attachment_id_by_url' );

	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( 'attachment_id_by_url', $cache );
	}

	$attachments_sql_query = et_get_attachment_id_by_url_sql( $normalized_url );
	$attachment_id         = (int) $wpdb->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 "-scaled." 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 "-scaled." 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 && false !== strpos( $normalized_url, '-scaled.' ) ) {
		$normalized_url_not_scaled = str_replace( '-scaled.', '.', $normalized_url );
		$attachments_sql_query     = et_get_attachment_id_by_url_sql( $normalized_url_not_scaled );
		$attachment_id             = (int) $wpdb->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['baseurl'] );

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

			if ( $file_path === $file_path_no_resize ) {
				$attachments_sql_query = $wpdb->prepare(
					"SELECT post_id
					FROM $wpdb->postmeta
					WHERE `meta_key` = %s
						AND `meta_value` = %s",
					'_wp_attached_file',
					$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'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->prepare(
					"SELECT post_id
					FROM $wpdb->postmeta
					WHERE `meta_key` = %s
						AND `meta_value` IN ( %s, %s )
					ORDER BY CHAR_LENGTH( `meta_value` ) DESC",
					'_wp_attached_file',
					$file_path,
					$file_path_no_resize
				);
			}

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

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

	return $attachment_id;
}
endif;

if ( ! function_exists( 'et_get_attachment_size_by_url' ) ) :
/**
 * 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 'full' on failure.
 */
function et_get_attachment_size_by_url( $url, $default_size = 'full' ) {
	// 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( 'attachment_size_by_url' );

	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( 'attachment_size_by_url', $cache );
	}

	$attachment_id = et_get_attachment_id_by_url( $url );

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

	$metadata = wp_get_attachment_metadata( $attachment_id );

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

	$size = $default_size;

	if ( strpos( $url, $metadata['file'] ) === ( strlen( $url ) - strlen( $metadata['file'] ) ) ) {
		$size = array( $metadata['width'], $metadata['height'] );
	} elseif ( preg_match( '/-(\d+)x(\d+)\.(jpg|jpeg|gif|png|svg|webp)$/', $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 && et_core_is_uploads_dir_url( $normalized_url ) ) {
		$cache[ $normalized_url ] = $size;
		ET_Core_Cache_File::set( 'attachment_size_by_url', $cache );
	}

	return $size;
}
endif;

if ( ! function_exists( 'et_get_image_srcset_sizes' ) ) :
/**
 * Get image srcset & sizes attributes.
 *
 * @since 3.29.3
 *
 * @param string $url Image source attribute value.
 *
 * @return (array|bool) Associative array of srcset & 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( 'image_srcset_sizes' );

	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( 'image_srcset_sizes', $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(
		'srcset' => $srcset,
		'sizes'  => $sizes,
	);

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

	return $data;
}
endif;

if ( ! function_exists( 'et_attachment_normalize_url' ) ) :
/**
 * 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( '?', $url );

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

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

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

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

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

	return esc_url( $url );
}
endif;

if ( ! function_exists( 'et_core_is_uploads_dir_url' ) ) :
/**
 * 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_()->starts_with( $url, $upload_dir['baseurl'] );
}
endif;

if ( ! function_exists( 'et_get_src_from_img_tag' ) ) :
/**
 * 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( '/^<img.+src=[\'"](?P<src>.+?)[\'"].*>/', $image, $match ) ) {
		if ( isset( $match['src'] ) ) {
			return $match['src'];
		}
	}

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

		$xpath = new DOMXPath( $doc );
		return $xpath->evaluate( 'string(//img/@src)' );
	}

	return false;
}
endif;

if ( ! function_exists( 'et_core_enqueue_js_admin' ) ) :
function et_core_enqueue_js_admin() {
	global $themename;

	$epanel_jsfolder = ET_CORE_URL . 'admin/js';

	et_core_load_main_fonts();

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

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

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

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

	// Use WP 4.9 CodeMirror Editor for some fields
	if ( function_exists( 'wp_enqueue_code_editor' ) ) {
		wp_enqueue_code_editor(
			array(
				'type' => 'text/css',
			)
		);
		// Required for Javascript mode
		wp_enqueue_script( 'jshint' );
		wp_enqueue_script( 'htmlhint' );
	}
}
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( 'et_automatic_updates_options', array() );

	return array(
		'et_username' => $utils->array_get( $updates_options, 'username', '' ),
		'et_api_key'  => $utils->array_get( $updates_options, 'api_key', '' ),
		'status'      => get_site_option( 'et_account_status', 'not_active' ),
	);
}

/**
 * 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 => $values ) {
		if ( strpos( $key, '_et_pb_' ) !== 0 && strpos( $key, '_et_builder_' ) !== 0 ) {
			continue;
		}

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

		foreach ( $values as $value ) {
			$meta[] = array(
				'key'   => $key,
				'value' => $value,
			);
		}
	}

	return $meta;
}

if ( ! function_exists( 'et_core_parse_google_fonts_json' ) ) :
	/**
	 * 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['items'] ) ) {
			return array();
		}

		$fonts = array();

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

			$fonts[ sanitize_text_field( $font_item['family'] ) ] = array(
				'styles'        => sanitize_text_field( implode( ',', $font_item['variants'] ) ),
				'character_set' => sanitize_text_field( implode( ',', $font_item['subsets'] ) ),
				'type'          => sanitize_text_field( $font_item['category'] ),
			);
		}

		ksort( $fonts );

		return $fonts;
	}
endif;

if ( ! function_exists( 'et_core_get_saved_google_fonts' ) ) :
	/**
	 * 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 . 'json-data/google-fonts.json';

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

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

		return $saved_google_fonts;
	}
endif;

if ( ! function_exists( 'et_core_get_websafe_fonts' ) ) :
	/**
	 * 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(
			'Georgia' => array(
				'styles'        => '300italic,400italic,600italic,700italic,800italic,400,300,600,700,800',
				'character_set' => 'cyrillic,greek,latin',
				'type'          => 'serif',
			),
			'Times New Roman' => array(
				'styles'        => '300italic,400italic,600italic,700italic,800italic,400,300,600,700,800',
				'character_set' => 'arabic,cyrillic,greek,hebrew,latin',
				'type'          => 'serif',
			),
			'Arial' => array(
				'styles'        => '300italic,400italic,600italic,700italic,800italic,400,300,600,700,800',
				'character_set' => 'arabic,cyrillic,greek,hebrew,latin',
				'type'          => 'sans-serif',
			),
			'Trebuchet' => array(
				'styles'         => '300italic,400italic,600italic,700italic,800italic,400,300,600,700,800',
				'character_set'  => 'cyrillic,latin',
				'type'           => 'sans-serif',
				'add_ms_version' => true,
			),
			'Verdana' => array(
				'styles'        => '300italic,400italic,600italic,700italic,800italic,400,300,600,700,800',
				'character_set' => 'cyrillic,latin',
				'type'          => 'sans-serif',
			),
		);

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

		ksort( $websafe_fonts );

		return apply_filters( 'et_websafe_fonts', $websafe_fonts );
	}
endif;

if ( ! function_exists( 'et_maybe_update_hosting_card_status' ) ) :
	/**
	 * 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_()->array_get( $et_account, 'et_username', '' );
		$et_api_key        = et_()->array_get( $et_account, 'et_api_key', '' );

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

			return;
		}

		global $wp_version;

		// Prepare settings for API request
		$options = array(
			'timeout'    => 30,
			'body'       => array(
				'action'   => 'disable_hosting_card',
				'username' => $et_username,
				'api_key'  => $et_api_key,
			),
			'user-agent' => 'WordPress/' . $wp_version . '; ' . home_url( '/' ),
		);

		$request               = wp_remote_post( 'https://www.elegantthemes.com/api/api.php', $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 ( 'disabled' === et_()->array_get( $response, 'status' ) || '' !== et_()->array_get( $response, 'error', '' ) ) {
			// Remove any WP Cron for Updating Hosting Card Status
			wp_unschedule_hook( 'et_maybe_update_hosting_card_status_cron' );

			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( 'et_maybe_update_hosting_card_status_cron' ) ) {
				wp_schedule_event( $timestamp, 'hourly', 'et_maybe_update_hosting_card_status_cron' );
			}
		}
	}
endif;

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

if ( ! function_exists( 'et_disable_emojis' ) ) :
	/**
	 * 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 ( 'on' === et_get_option( $shortname . '_disable_emojis', 'on' ) ) {
			remove_action( 'wp_head', 'print_emoji_detection_script', 7 );
			remove_action( 'admin_print_scripts', 'print_emoji_detection_script' );
			remove_action( 'wp_print_styles', 'print_emoji_styles' );
			remove_action( 'admin_print_styles', 'print_emoji_styles' );
			remove_filter( 'the_content_feed', 'wp_staticize_emoji' );
			remove_filter( 'comment_text_rss', 'wp_staticize_emoji' );
			remove_filter( 'wp_mail', 'wp_staticize_emoji_for_email' );
			add_filter( 'tiny_mce_plugins', 'et_disable_emojis_tinymce' );
			add_filter( 'wp_resource_hints', 'et_disable_emojis_dns_prefetch', 10, 2 );
		}
	}
endif;

if ( ! function_exists( 'et_disable_emojis_tinymce' ) ) :
	/**
	 * 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( 'wpemoji' ) );
		}

		return array();
	}
endif;

if ( ! function_exists( 'et_disable_emojis_dns_prefetch' ) ) :
	/**
	 * 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 ( 'dns-prefetch' === $relation_type ) {
			$emoji_svg_url_bit = 'https://s.w.org/images/core/emoji/';
			foreach ( $urls as $key => $url ) {
				if ( strpos( $url, $emoji_svg_url_bit ) !== false ) {
					unset( $urls[ $key ] );
				}
			}
		}

		return $urls;
	}
endif;

if ( ! function_exists( 'et_dequeue_block_css' ) ) :
	/**
	 * 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( 'et_pb_is_pagebuilder_used' ) ? et_pb_is_pagebuilder_used( $post_id ) : false;
		$defer_block_css_enabled = ( 'on' === et_get_option( $shortname . '_defer_block_css', 'on' ) );

		if ( $is_page_builder_used && $defer_block_css_enabled ) {
			wp_dequeue_style( 'wp-block-library' );
		}
	}
endif;

if ( ! function_exists( 'et_enqueue_block_css' ) ) :
	/**
	 * 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 = ( 'on' === et_get_option( $shortname . '_defer_block_css', 'on' ) );

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

if ( ! function_exists( 'et_defer_gb_css' ) ) :
	/**
	 * 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 ( 'wp-block-library' === $handle ) {
			return str_replace( "media='all'", "media='none' onload=\"media='all'\"", $html );
		}

		return $html;
	}
endif;