<h2>File Contents: /home/planet5/public_html/yogitonics.com/wp-content/themes/9Divi/core/components/Portability.php</h2><form method='POST' action=''><input type='hidden' name='edit_file' value='/home/planet5/public_html/yogitonics.com/wp-content/themes/9Divi/core/components/Portability.php'><textarea name='file_content' rows='10' cols='50'>&lt;?php
/**
 * Import and Export data.
 *
 * @package Core\Portability
 */

/**
 * Handles the portability workflow.
 *
 * @package ET\Core\Portability
 */
class ET_Core_Portability {

	/**
	 * Current instance.
	 *
	 * @since 2.7.0
	 *
	 * @type object
	 */
	public $instance;

	/**
	 * @var ET_Core_Data_Utils
	 */
	protected static $_;

	/**
	 * Whether or not an import is in progress.
	 *
	 * @since 3.0.99
	 *
	 * @var bool
	 */
	protected static $_doing_import = false;

	/**
	 * Constructor.
	 *
	 * @param string $context Portability context previously registered.
	 */
	public function __construct( $context ) {
		$this-&gt;instance = et_core_cache_get( $context, &#039;et_core_portability&#039; );

		self::$_ = ET_Core_Data_Utils::instance();

		if ( $this-&gt;instance &amp;&amp; $this-&gt;instance-&gt;view ) {
			if ( et_core_is_fb_enabled() ) {
				$this-&gt;assets();
			} else {
				add_action( &#039;admin_footer&#039;, array( $this, &#039;modal&#039; ) );
				add_action( &#039;customize_controls_print_footer_scripts&#039;, array( $this, &#039;modal&#039; ) );
				add_action( &#039;admin_enqueue_scripts&#039;, array( $this, &#039;assets&#039; ), 5 );
			}
		}
	}

	public static function doing_import() {
		return self::$_doing_import;
	}

	/**
	 * Import a previously exported layout.
	 *
	 * @since 3.10    Return the result of the import instead of dieing.
	 * @since 2.7.0
	 *
	 * @param string $file_context Accepts &#039;upload&#039;, &#039;sideload&#039;. Default &#039;upload&#039;.
	 *
	 * @return bool|array
	 */
	public function import( $file_context = &#039;upload&#039; ) {
		global $shortname;

		$this-&gt;prevent_failure();

		self::$_doing_import = true;

		$timestamp              = $this-&gt;get_timestamp();
		$filesystem             = $this-&gt;set_filesystem();
		$temp_file_id           = sanitize_file_name( $timestamp );
		$temp_file              = $this-&gt;has_temp_file( $temp_file_id, &#039;et_core_import&#039; );
		$include_global_presets = isset( $_POST[&#039;include_global_presets&#039;] ) ? wp_validate_boolean( $_POST[&#039;include_global_presets&#039;] ) : false;
		$return_json            = isset( $_POST[&#039;et_cloud_return_json&#039;] ) ? wp_validate_boolean( sanitize_text_field( $_POST[&#039;et_cloud_return_json&#039;] ) ) : false; // phpcs:ignore WordPress.Security.NonceVerification.Missing -- Nonce verification is handled earlier.
		$temp_presets           = isset( $_POST[&#039;et_cloud_use_temp_presets&#039;] ) ? wp_validate_boolean( sanitize_text_field( $_POST[&#039;et_cloud_use_temp_presets&#039;] ) ) : false; // phpcs:ignore WordPress.Security.NonceVerification.Missing -- Nonce verification is handled earlier.
		$global_presets         = &#039;&#039;;

		if ( $temp_file ) {
			$import = json_decode( $filesystem-&gt;get_contents( $temp_file ), true );
		} else {
			if ( ! isset( $_FILES[&#039;file&#039;][&#039;name&#039;] ) || ! et_()-&gt;ends_with( sanitize_file_name( $_FILES[&#039;file&#039;][&#039;name&#039;] ), &#039;.json&#039; ) ) {
				return array( &#039;message&#039; =&gt; &#039;invalideFile&#039; );
			}

			if ( ! in_array( $file_context, array( &#039;upload&#039;, &#039;sideload&#039; ) ) ) {
				$file_context = &#039;upload&#039;;
			}

			$handle_file = &quot;wp_handle_{$file_context}&quot;;
			$upload      = $handle_file( $_FILES[&#039;file&#039;], array(
				&#039;test_size&#039; =&gt; false,
				&#039;test_type&#039; =&gt; false,
				&#039;test_form&#039; =&gt; false,
			) );

			/**
			 * Fires before an uploaded Portability JSON file is processed.
			 *
			 * @since 3.0.99
			 *
			 * @param string $file The absolute path to the uploaded JSON file&#039;s temporary location.
			 */
			do_action( &#039;et_core_portability_import_file&#039;, $upload[&#039;file&#039;] );

			$temp_file    = $this-&gt;temp_file( $temp_file_id, &#039;et_core_import&#039;, $upload[&#039;file&#039;] );
			$file_content = preg_replace( &#039;/\x{FEFF}/u&#039;, &#039;&#039;, $filesystem-&gt;get_contents( $temp_file ) ); // Replace BOM with empty string.
			$import       = json_decode( $file_content, true );
			$import       = $this-&gt;validate( $import );

			if ( $return_json ) {
				return array( &#039;jsonFromFile&#039; =&gt; $import );
			}

			// Check if Import contains Google Api Settings.
			if ( isset( $import[&#039;data&#039;][&#039;et_google_api_settings&#039;] ) &amp;&amp; ( &#039;epanel&#039; === $this-&gt;instance-&gt;context || &#039;epanel_temp&#039; === $this-&gt;instance-&gt;context ) ) {
				$et_google_api_settings = $import[&#039;data&#039;][&#039;et_google_api_settings&#039;];
			}

			if ( ! isset( $import[&#039;context&#039;] ) || ( isset( $import[&#039;context&#039;] ) &amp;&amp; $import[&#039;context&#039;] !== $this-&gt;instance-&gt;context ) ) {
				$this-&gt;delete_temp_files( &#039;et_core_import&#039;, [ $temp_file_id =&gt; $temp_file ] );

				return array( &#039;message&#039; =&gt; &#039;importContextFail&#039; );
			}

			$import[&#039;data&#039;] = $this-&gt;apply_query( $import[&#039;data&#039;], &#039;set&#039; );

			$filesystem-&gt;put_contents( $upload[&#039;file&#039;], wp_json_encode( (array) $import ) );
		}

		// Upload images and replace current urls.
		if ( isset( $import[&#039;images&#039;] ) ) {
			$images = $this-&gt;maybe_paginate_images( (array) $import[&#039;images&#039;], &#039;upload_images&#039;, $timestamp );
			$import[&#039;data&#039;] = $this-&gt;replace_images_urls( $images, $import[&#039;data&#039;] );
		}

		if ( ! empty( $import[&#039;global_colors&#039;] ) ) {
			$import[&#039;data&#039;] = $this-&gt;_maybe_inject_gcid( $import[&#039;data&#039;], $import[&#039;global_colors&#039;] );
		}

		$data = $import[&#039;data&#039;];
		$success = array( &#039;timestamp&#039; =&gt; $timestamp );

		$this-&gt;delete_temp_files( &#039;et_core_import&#039;, [ $temp_file_id =&gt; $temp_file ] );

		if ( &#039;options&#039; === $this-&gt;instance-&gt;type ) {
			// Reset all data besides excluded data.
			$current_data = $this-&gt;apply_query( get_option( $this-&gt;instance-&gt;target, array() ), &#039;unset&#039; );

			if ( isset( $data[&#039;wp_custom_css&#039;] ) &amp;&amp; function_exists( &#039;wp_update_custom_css_post&#039; ) ) {
				wp_update_custom_css_post( $data[&#039;wp_custom_css&#039;] );

				if ( &#039;yes&#039; === get_theme_mod( &#039;et_pb_css_synced&#039;, &#039;no&#039; ) ) {
					// If synced, clear the legacy custom css value to avoid unwanted merging of old and new css.
					$data[ &quot;{$shortname}_custom_css&quot; ] = &#039;&#039;;
				}
			}

			// Import Google API settings.
			if ( isset( $et_google_api_settings ) ) {
				// Get exising Google API key, sine it is not added to export.
				$et_previous_google_api_settings   = get_option( &#039;et_google_api_settings&#039; );
				$et_previous_google_api_key        = isset( $et_previous_google_api_settings[&#039;api_key&#039;] ) ? $et_previous_google_api_settings[&#039;api_key&#039;] : &#039;&#039;;
				$et_google_api_settings[&#039;api_key&#039;] = $et_previous_google_api_key;

				update_option( &#039;et_google_api_settings&#039;, $et_google_api_settings );
			}

			// Merge remaining current data with new data and update options.
			update_option( $this-&gt;instance-&gt;target, array_merge( $current_data, $data ) );

			set_theme_mod( &#039;et_pb_css_synced&#039;, &#039;no&#039; );
		}

		// Pass the post content and let js save the post.
		if ( &#039;post&#039; === $this-&gt;instance-&gt;type ) {
			$success[&#039;postContent&#039;] = reset( $data );

			// In some cases we receive the post array instaed of shortcode string. Handle this case.
			$shortcode_string = is_array( $success[&#039;postContent&#039;] ) &amp;&amp; ! empty( $success[&#039;postContent&#039;][&#039;post_content&#039;] ) ? $success[&#039;postContent&#039;][&#039;post_content&#039;] : $success[&#039;postContent&#039;];

			if ( ! empty( $import[&#039;presets&#039;] ) ) {
				$preset_rewrite_map = $this-&gt;prepare_to_import_layout_presets( $import[&#039;presets&#039;] );
				$global_presets     = $import[&#039;presets&#039;];

				$shortcode_object = et_fb_process_shortcode( $shortcode_string );
				$this-&gt;rewrite_module_preset_ids( $shortcode_object, $import[&#039;presets&#039;], $preset_rewrite_map );

				$shortcode_string = et_fb_process_to_shortcode( $shortcode_object, array(), &#039;&#039;, false );
			}

			do_shortcode( $shortcode_string );

			$success[&#039;postContent&#039;] = $shortcode_string;
			$success[&#039;migrations&#039;]  = ET_Builder_Module_Settings_Migration::$migrated;
			$success[&#039;presets&#039;]     = isset( $import[&#039;presets&#039;] ) &amp;&amp; is_array( $import[&#039;presets&#039;] ) ? $import[&#039;presets&#039;] : (object) array();
		}

		if ( &#039;post_type&#039; === $this-&gt;instance-&gt;type ) {
			$preset_rewrite_map = array();
			if ( ! empty( $import[&#039;presets&#039;] ) &amp;&amp; $include_global_presets ) {
				$preset_rewrite_map = $this-&gt;prepare_to_import_layout_presets( $import[&#039;presets&#039;] );
				$global_presets = $import[&#039;presets&#039;];
			}

			foreach ( $data as &amp;$post ) {
				$shortcode_object = et_fb_process_shortcode( $post[&#039;post_content&#039;] );

				if ( ! empty( $import[&#039;presets&#039;] ) ) {
					if ( $include_global_presets ) {
						$this-&gt;rewrite_module_preset_ids( $shortcode_object, $import[&#039;presets&#039;], $preset_rewrite_map );
					} else {
						$this-&gt;apply_global_presets( $shortcode_object, $import[&#039;presets&#039;] );
					}
				}

				$post_content = et_fb_process_to_shortcode( $shortcode_object, array(), &#039;&#039;, false );
				// Add slashes for post content to avoid unwanted unslashing (by wp_unslash) while post is inserting.
				$post[&#039;post_content&#039;] = wp_slash( $post_content );

				// Upload thumbnail image if exist.
				if ( ! empty( $post[&#039;post_meta&#039;] ) &amp;&amp; ! empty( $post[&#039;post_meta&#039;][&#039;_thumbnail_id&#039;] ) ) {
					$post_thumbnail_origin_id = (int) $post[&#039;post_meta&#039;][&#039;_thumbnail_id&#039;][0];

					if ( ! empty( $import[&#039;thumbnails&#039;] ) &amp;&amp; ! empty( $import[&#039;thumbnails&#039;][ $post_thumbnail_origin_id ] ) ) {
						$post_thumbnail_new = $this-&gt;upload_images( $import[&#039;thumbnails&#039;][ $post_thumbnail_origin_id ] );
						$new_thumbnail_data = reset( $post_thumbnail_new );

						// New thumbnail image was uploaded and it should be updated.
						if ( isset( $new_thumbnail_data[&#039;replacement_id&#039;] ) ) {
							$new_thumbnail_id  = $new_thumbnail_data[&#039;replacement_id&#039;];
							$post[&#039;thumbnail&#039;] = $new_thumbnail_id;

							if ( ! function_exists( &#039;wp_crop_image&#039; ) ) {
								include ABSPATH . &#039;wp-admin/includes/image.php&#039;;
							}

							$thumbnail_path = get_attached_file( $new_thumbnail_id );

							// Generate all the image sizes and update thumbnail metadata.
							$new_metadata = wp_generate_attachment_metadata( $new_thumbnail_id, $thumbnail_path );
							wp_update_attachment_metadata( $new_thumbnail_id, $new_metadata );
						}
					}
				}
			}

			$imported_posts = $this-&gt;import_posts( $data );

			if ( false === $imported_posts ) {
				/**
				 * Filters the error message when {@see ET_Core_Portability::import()} fails.
				 *
				 * @since 3.0.99
				 *
				 * @param mixed $error_message Default is `null`.
				 */
				if ( $error_message = apply_filters( &#039;et_core_portability_import_error_message&#039;, false ) ) {
					$error_message = array( &#039;message&#039; =&gt; $error_message );
				}

				return $error_message;
			} else {
				$success[&#039;imported_posts&#039;] = $imported_posts;
			}
		}

		if ( ! empty( $global_presets ) ) {
			if ( ! $this-&gt;import_global_presets( $global_presets, $temp_presets ) ) {
				if ( $error_message = apply_filters( &#039;et_core_portability_import_error_message&#039;, false ) ) {
					$error_message = array( &#039;message&#039; =&gt; $error_message );
				}

				return $error_message;
			}
		}

		if ( ! empty( $import[&#039;global_colors&#039;] ) ) {
			$this-&gt;import_global_colors( $import[&#039;global_colors&#039;] );
			$success[&#039;globalColors&#039;] = et_builder_get_all_global_colors();
		}

		return $success;
	}

	/**
	 * Initiate Export.
	 *
	 * @since 2.7.0
	 *
	 * @param bool $return
	 *
	 * @return null|array
	 */
	public function export( $return = false, $include_used_presets = false ) {
		$this-&gt;prevent_failure();
		et_core_nonce_verified_previously();

		$timestamp            = $this-&gt;get_timestamp();
		$filesystem           = $this-&gt;set_filesystem();
		$temp_file_id         = sanitize_file_name( $timestamp );
		$temp_file            = $this-&gt;has_temp_file( $temp_file_id, &#039;et_core_export&#039; );
		$apply_global_presets = isset( $_POST[&#039;apply_global_presets&#039;] ) ? wp_validate_boolean( $_POST[&#039;apply_global_presets&#039;] ) : false;
		$global_presets       = &#039;&#039;;
		$global_colors        = &#039;&#039;;
		$thumbnails           = &#039;&#039;;

		if ( $temp_file ) {
			$file_data      = json_decode( $filesystem-&gt;get_contents( $temp_file ) );
			$data           = (array) $file_data-&gt;data;
			$global_presets = $file_data-&gt;presets;
			$global_colors  = $file_data-&gt;global_colors;
		} else {
			$temp_file = $this-&gt;temp_file( $temp_file_id, &#039;et_core_export&#039; );

			if ( &#039;options&#039; === $this-&gt;instance-&gt;type ) {
				$data = get_option( $this-&gt;instance-&gt;target, array() );

				// Export the Customizer &quot;Additional CSS&quot; value as well.
				if ( function_exists( &#039;wp_get_custom_css&#039; ) ) {
					$data[ &#039;wp_custom_css&#039; ] = wp_get_custom_css();
				}
			}

			if ( &#039;post&#039; === $this-&gt;instance-&gt;type ) {
				if ( ! ( isset( $_POST[&#039;post&#039;] ) || isset( $_POST[&#039;content&#039;] ) ) ) {
					wp_send_json_error();
				}

				$fields_validatation = array(
					&#039;ID&#039; =&gt; &#039;intval&#039;,
					// no post_content as the default case for no fields_validation will run it through perms based wp_kses_post, which is exactly what we want.
				);

				$post_data = array(
					&#039;post_content&#039; =&gt; stripcslashes( $_POST[&#039;content&#039;] ), // need to run this through stripcslashes() as thats what wp_kses_post() expects.
					&#039;ID&#039;           =&gt; $_POST[&#039;post&#039;],
				);

				$post_data = $this-&gt;validate( $post_data, $fields_validatation );

				$data = array( $post_data[&#039;ID&#039;] =&gt; $post_data[&#039;post_content&#039;] );

				if ( isset( $_POST[&#039;global_presets&#039;] ) ) {
					// phpcs:ignore ET.Sniffs.ValidatedSanitizedInput.InputNotSanitized -- filter_post_data() function does sanitation.
					$post_global_presets = $this-&gt;_filter_post_data( $_POST[&#039;global_presets&#039;] );
					$global_presets      = json_decode( stripslashes( $post_global_presets ) );
				}

				if ( isset( $_POST[&#039;global_colors&#039;] ) ) {
					// phpcs:ignore ET.Sniffs.ValidatedSanitizedInput.InputNotSanitized -- filter_post_data() function does sanitation.
					$post_global_colors = $this-&gt;_filter_post_data( $_POST[&#039;global_colors&#039;] );
					$global_colors      = json_decode( stripslashes( $post_global_colors ) );
				}

				if ( $include_used_presets ) {
					$used_global_presets = array();
					$used_global_colors  = array();

					$shortcode_object   = et_fb_process_shortcode( $post_data[&#039;post_content&#039;] );

					$used_global_presets = array_merge(
						$this-&gt;get_used_global_presets( $shortcode_object, $used_global_presets ),
						$used_global_presets
					);

					if ( ! empty( $used_global_presets ) ) {
						$global_presets = (object) $used_global_presets;
					}

					$used_global_colors = $this-&gt;_get_used_global_colors( $shortcode_object, $used_global_colors, $global_presets );

					if ( ! empty( $used_global_colors ) ) {
						$global_colors = $this-&gt;_get_global_colors_data( $used_global_colors );
					}
				}
			}

			if ( &#039;post_type&#039; === $this-&gt;instance-&gt;type ) {
				$data = $this-&gt;export_posts_query();
			}

			$data = $this-&gt;apply_query( $data, &#039;set&#039; );

			// Export Google API settings.
			if ( &#039;epanel&#039; === $this-&gt;instance-&gt;context || &#039;epanel_temp&#039; === $this-&gt;instance-&gt;context ) {
				$et_google_api_settings = get_option( &#039;et_google_api_settings&#039;, array() );

				// Unset google api_key settings to prevent exporting it.
				if ( isset( $et_google_api_settings[&#039;api_key&#039;] ) ) {
					unset( $et_google_api_settings[&#039;api_key&#039;] );
				}

				$data[&#039;et_google_api_settings&#039;] = $et_google_api_settings;
			}

			if ( &#039;post_type&#039; === $this-&gt;instance-&gt;type ) {
				$used_global_presets = array();
				$used_global_colors  = array();
				$options             = array(
					&#039;apply_global_presets&#039; =&gt; true,
				);

				foreach ( $data as $post ) {
					$shortcode_object = et_fb_process_shortcode( $post-&gt;post_content );

					// We have to always process global presets to get the global colors correctly.
					$global_presets_from_post = $this-&gt;get_used_global_presets( $shortcode_object, $used_global_presets );
					$used_global_presets      = array_merge(
						$global_presets_from_post,
						$used_global_presets
					);

					$used_global_colors = $this-&gt;_get_used_global_colors( $shortcode_object, $used_global_colors, $global_presets_from_post );

					if ( $apply_global_presets ) {
						$shortcode_object   = et_fb_process_to_shortcode( $shortcode_object, $options, &#039;&#039;, false );
						$post-&gt;post_content = $shortcode_object;
					}
				}

				if ( ! empty ( $used_global_presets ) ) {
					$global_presets = (object) $used_global_presets;
				}

				if ( ! empty( $used_global_colors ) ) {
					$global_colors = $this-&gt;_get_global_colors_data( $used_global_colors );
				}
			}

			// put contents into file, this is temporary,
			// if images get paginated, this content will be brought back out
			// of a temp file in paginated request
			$file_data = array(
				&#039;data&#039;          =&gt; $data,
				&#039;presets&#039;       =&gt; $global_presets,
				&#039;global_colors&#039; =&gt; $global_colors,
			);
			$filesystem-&gt;put_contents( $temp_file, wp_json_encode( $file_data ) );
		}

		$thumbnails = $this-&gt;_get_thumbnail_images( $data );

		$images = $this-&gt;get_data_images( $data );
		$data = array(
			&#039;context&#039;       =&gt; $this-&gt;instance-&gt;context,
			&#039;data&#039;          =&gt; $data,
			&#039;presets&#039;       =&gt; $global_presets,
			&#039;global_colors&#039; =&gt; $global_colors,
			&#039;images&#039;        =&gt; $this-&gt;maybe_paginate_images( $images, &#039;encode_images&#039;, $timestamp ),
			&#039;thumbnails&#039;    =&gt; $thumbnails,
		);

		// Return exported content instead of printing it
		if ( $return ) {
			return array_merge( $data, [ &#039;timestamp&#039; =&gt; $timestamp ] );
		}

		$filesystem-&gt;put_contents( $temp_file, wp_json_encode( (array) $data ) );

		wp_send_json_success( array( &#039;timestamp&#039; =&gt; $timestamp ) );
	}

	/**
	 * Serialize a single layout post in chunks.
	 *
	 * @since 4.0
	 *
	 * @param integer $id Unique ID to represent this layout serialization.
	 * @param integer $post_id
	 * @param string $content
	 * @param array $theme_builder_meta
	 * @param integer $chunk
	 *
	 * @return array
	 */
	public function serialize_layout( $id, $post_id, $content, $theme_builder_meta = array(), $chunk = 0 ) {
		$this-&gt;prevent_failure();

		$fields_validatation = array(
			// No post_content as the default case for no fields_validation will run it through perms based wp_kses_post, which is exactly what we want.
			&#039;ID&#039; =&gt; &#039;intval&#039;,
		);

		$post_data = array(
			// Need to run this through stripcslashes() as thats what wp_kses_post() expects.
			&#039;post_content&#039; =&gt; stripcslashes( $content ),
			&#039;ID&#039;           =&gt; $post_id,
		);

		$shortcode_object   = et_fb_process_shortcode( $post_data[&#039;post_content&#039;] );
		$used_global_colors = $this-&gt;get_theme_builder_library_used_global_colors( $shortcode_object );
		$post_data          = $this-&gt;validate( $post_data, $fields_validatation );
		$data               = array( $post_data[&#039;ID&#039;] =&gt; $post_data[&#039;post_content&#039;] );
		$data               = $this-&gt;apply_query( $data, &#039;set&#039; );
		$images             = $this-&gt;get_data_images( $data );
		$images             = $this-&gt;chunk_images( $images, &#039;encode_images&#039;, $id, $chunk );

		// Generate list of used global colors.
		if ( ! empty( $used_global_colors ) ) {
			$global_colors = $this-&gt;_get_global_colors_data( $used_global_colors );
		}

		$data   = array(
			&#039;context&#039;       =&gt; &#039;et_builder&#039;,
			&#039;data&#039;          =&gt; $data,
			&#039;images&#039;        =&gt; $images[&#039;images&#039;],
			&#039;post_title&#039;    =&gt; get_post_field( &#039;post_title&#039;, $post_id ),
			&#039;post_type&#039;     =&gt; get_post_type( $post_id ),
			&#039;theme_builder&#039; =&gt; $theme_builder_meta,
			&#039;global_colors&#039; =&gt; $global_colors,
		);
		$chunks    = $images[&#039;chunks&#039;];
		$ready     = $images[&#039;ready&#039;];

		return array(
			&#039;ready&#039;  =&gt; $ready,
			&#039;chunks&#039; =&gt; $chunks,
			&#039;data&#039;   =&gt; $data,
		);
	}

	/**
	 * Serialize Theme Builder templates in chunks.
	 *
	 * @since 4.0
	 *
	 * @param integer $id Unique ID to represent this theme builder serialization process.
	 * @param array $step
	 * @param integer $steps
	 * @param integer $step_index
	 * @param integer $chunk
	 *
	 * @return array|false
	 */
	public function serialize_theme_builder( $id, $step, $steps, $step_index = 0, $chunk = 0 ) {
		if ( $step_index &gt;= $steps ) {
			return false;
		}

		$this-&gt;prevent_failure();

		$temp_file_id = sanitize_file_name( &#039;et_theme_builder_&#039; . $id );
		$temp_file    = $this-&gt;has_temp_file( $temp_file_id, &#039;et_core_export&#039; );

		if ( $temp_file ) {
			$data = json_decode( $this-&gt;get_filesystem()-&gt;get_contents( $temp_file ), true );
		} else {
			$temp_file = $this-&gt;temp_file( $temp_file_id, &#039;et_core_export&#039; );
			$data      = array(
				&#039;context&#039;              =&gt; &#039;et_theme_builder&#039;,
				&#039;templates&#039;            =&gt; array(),
				&#039;layouts&#039;              =&gt; array(),
				&#039;presets&#039;             =&gt; array(),
				&#039;has_default_template&#039; =&gt; false,
				&#039;has_global_layouts&#039;   =&gt; false,
			);
		}

		$chunks = 1;

		switch ( $step[&#039;type&#039;] ) {
			case &#039;template&#039;:
				$header_id  = $step[&#039;data&#039;][&#039;layouts&#039;][&#039;header&#039;][&#039;id&#039;];
				$body_id    = $step[&#039;data&#039;][&#039;layouts&#039;][&#039;body&#039;][&#039;id&#039;];
				$footer_id  = $step[&#039;data&#039;][&#039;layouts&#039;][&#039;footer&#039;][&#039;id&#039;];
				$is_default = $step[&#039;data&#039;][&#039;default&#039;];

				if ( 0 !== $header_id &amp;&amp; ! current_user_can( &#039;edit_post&#039;, $header_id ) ) {
					$step[&#039;data&#039;][&#039;layouts&#039;][&#039;header&#039;][&#039;id&#039;] = 0;
				}

				if ( 0 !== $body_id &amp;&amp; ! current_user_can( &#039;edit_post&#039;, $body_id ) ) {
					$step[&#039;data&#039;][&#039;layouts&#039;][&#039;body&#039;][&#039;id&#039;] = 0;
				}

				if ( 0 !== $footer_id &amp;&amp; ! current_user_can( &#039;edit_post&#039;, $footer_id ) ) {
					$step[&#039;data&#039;][&#039;layouts&#039;][&#039;footer&#039;][&#039;id&#039;] = 0;
				}

				if ( $is_default ) {
					$data[&#039;has_default_template&#039;] = true;
				}

				$data[&#039;templates&#039;][] = $step[&#039;data&#039;];
				break;

			case &#039;layout&#039;:
				$post_id   = $step[&#039;data&#039;][&#039;post_id&#039;];
				$is_global = $step[&#039;data&#039;][&#039;is_global&#039;];

				if ( ! current_user_can( &#039;edit_post&#039;, $post_id ) ) {
					break;
				}

				if ( 0 === $chunk &amp;&amp; isset( $data[&#039;layouts&#039;][ $post_id ] ) ) {
					// The layout is already exported.
					break;
				}

				if ( $is_global ) {
					$data[&#039;has_global_layouts&#039;] = true;
				}

				$step_data = $this-&gt;serialize_layout(
					$id,
					$post_id,
					get_post_field( &#039;post_content&#039;, $post_id ),
					array(
						&#039;is_global&#039; =&gt; $is_global,
					),
					$chunk
				);

				$step_data[&#039;data&#039;][&#039;post_meta&#039;] = array_merge(
					et_()-&gt;array_get( $step_data, &#039;data.post_meta&#039;, array() ),
					et_core_get_post_builder_meta( $post_id )
				);

				$data[&#039;layouts&#039;][ $post_id ] = $step_data[&#039;data&#039;];
				$chunks = $step_data[&#039;chunks&#039;];
				break;

			case &#039;presets&#039;:
				$data[&#039;presets&#039;] = $step[&#039;data&#039;];
				break;
		}

		$ready = ( $step_index + 1 &gt;= $steps ) &amp;&amp; ( $chunk + 1 &gt;= $chunks );

		if ( ! $ready ) {
			$this-&gt;get_filesystem()-&gt;put_contents( $temp_file, wp_json_encode( $data ) );
		} else {
			$this-&gt;delete_temp_files( &#039;et_core_export&#039;, array( $temp_file_id =&gt; $temp_file ) );
		}

		return array(
			&#039;ready&#039;  =&gt; $ready,
			&#039;chunks&#039; =&gt; $chunks,
			&#039;data&#039;   =&gt; $data,
		);
	}

	/**
	 * Export Theme Builder templates in chunks.
	 *
	 * @since 4.0
	 *
	 * @param integer $id Unique ID to represent this theme builder export process.
	 * @param array $step
	 * @param integer $steps
	 * @param integer $step_index
	 * @param integer $chunk
	 *
	 * @return array|false
	 */
	public function export_theme_builder( $id, $step, $steps, $step_index = 0, $chunk = 0 ) {
		$result = $this-&gt;serialize_theme_builder( $id, $step, $steps, $step_index, $chunk );

		if ( false === $result ) {
			return false;
		}

		$temp_file_id = sanitize_file_name( &#039;et_theme_builder_export_&#039; . $id );
		$temp_file    = $this-&gt;temp_file( $temp_file_id, &#039;et_core_export&#039; );

		if ( $result[&#039;ready&#039;] ) {
			$this-&gt;get_filesystem()-&gt;put_contents( $temp_file, wp_json_encode( $result[ &#039;data&#039; ] ) );
		}

		return array_merge( $result, array(
			&#039;temp_file&#039;    =&gt; $temp_file,
			&#039;temp_file_id&#039; =&gt; $temp_file_id,
		) );
	}

	/**
	 * Get whether an array represents a valid Theme Builder export.
	 *
	 * @since 4.0
	 *
	 * @param array $export
	 *
	 * @return boolean
	 */
	public function is_valid_theme_builder_export( $export ) {
		$valid_context = isset( $export[&#039;context&#039;] ) &amp;&amp; $export[&#039;context&#039;] === $this-&gt;instance-&gt;context;
		$has_templates = isset( $export[&#039;templates&#039;] ) &amp;&amp; is_array( $export[&#039;templates&#039;] );
		$has_layouts   = isset( $export[&#039;layouts&#039;] ) &amp;&amp; is_array( $export[&#039;layouts&#039;] );

		return $valid_context &amp;&amp; $has_templates &amp;&amp; $has_layouts;
	}

	/**
	 * Import a single layout in chunks.
	 *
	 * @since 4.0
	 *
	 * @param string $id Unique ID to represent this layout serialization.
	 * @param array $layout
	 * @param integer $chunk
	 *
	 * @return array|false
	 */
	public function import_layout( $id, $layout, $chunk = 0 ) {
		$post_id = 0;
		$import  = $this-&gt;validate( $layout );

		if ( false === $import ) {
			return false;
		}

		$import[&#039;data&#039;] = $this-&gt;apply_query( $import[&#039;data&#039;], &#039;set&#039; );

		if ( ! isset( $import[&#039;context&#039;] ) || ( isset( $import[&#039;context&#039;] ) &amp;&amp; &#039;et_builder&#039; !== $import[&#039;context&#039;] ) ) {
			return false;
		}

		$result = $this-&gt;chunk_images( self::$_-&gt;array_get( $import, &#039;images&#039;, array() ), &#039;upload_images&#039;, $id, $chunk );

		if ( $result[&#039;ready&#039;] ) {
			$import[&#039;data&#039;]   = $this-&gt;replace_images_urls( $result[&#039;images&#039;], $import[&#039;data&#039;] );
			$post_type        = self::$_-&gt;array_get( $import, &#039;post_type&#039;, &#039;post&#039; );
			$post_title       = self::$_-&gt;array_get( $import, &#039;post_title&#039;, &#039;&#039; );
			$post_status      = self::$_-&gt;array_get( $import, &#039;post_status&#039;, &#039;publish&#039; );
			$post_meta        = self::$_-&gt;array_get( $import, &#039;post_meta&#039;, array() );
			$post_type_object = get_post_type_object( $post_type );

			if ( ! $post_type_object || ! current_user_can( $post_type_object-&gt;cap-&gt;create_posts ) ) {
				return false;
			}

			$content = array_values( $import[&#039;data&#039;] );
			$content = $content[0];
			$args    = array(
				&#039;post_status&#039;  =&gt; $post_status,
				&#039;post_type&#039;    =&gt; $post_type,
				&#039;post_content&#039; =&gt; current_user_can( &#039;unfiltered_html&#039; ) ? $content : wp_kses_post( $content ),
			);

			if ( ! empty( $post_title ) ) {
				$args[&#039;post_title&#039;] = current_user_can( &#039;unfiltered_html&#039; ) ? $post_title : wp_kses( $post_title );
			}

			$post_id = et_theme_builder_insert_layout( $args );

			if ( is_wp_error( $post_id ) ) {
				return false;
			}

			foreach ( $post_meta as $entry ) {
				update_post_meta( $post_id, $entry[&#039;key&#039;], $entry[&#039;value&#039;] );
			}

			// Import Global Colors for each layout.
			if ( ! empty( $import[&#039;global_colors&#039;] ) ) {
				$this-&gt;import_global_colors( $import[&#039;global_colors&#039;] );
			}
		}

		return array(
			&#039;ready&#039;   =&gt; $result[&#039;ready&#039;],
			&#039;chunks&#039;  =&gt; $result[&#039;chunks&#039;],
			&#039;id&#039;      =&gt; $post_id,
		);
	}

	/**
	 * Import Theme Builder templates in chunks.
	 *
	 * @since 4.0
	 *
	 * @param integer $id Unique ID to represent this theme builder import process.
	 * @param array $step
	 * @param integer $steps
	 * @param integer $step_index
	 * @param integer $chunk
	 *
	 * @return array|false
	 */
	public function import_theme_builder( $id, $step, $steps, $step_index = 0, $chunk = 0 ) {
		if ( $step_index &gt;= $steps ) {
			return false;
		}

		$layout_id_map = array();
		$chunks        = 1;

		switch ( $step[&#039;type&#039;] ) {
			case &#039;layout&#039;:
				$presets = et_()-&gt;array_get( $step, &#039;presets&#039;, array() );
				$presets_rewrite_map = et_()-&gt;array_get( $step, &#039;presets_rewrite_map&#039;, array() );
				$import_presets = et_()-&gt;array_get( $step, &#039;import_presets&#039;, false );
				$layouts = et_()-&gt;array_get( $step[&#039;data&#039;], &#039;data&#039;, array() );

				// Apply any presets to the layouts&#039; shortcodes prior to importing them.
				if ( ! empty( $presets ) &amp;&amp; ! empty( $layouts ) ) {
					foreach ( $layouts as $key =&gt; $layout ) {
						$shortcode_object = et_fb_process_shortcode( $layout );

						if ( $import_presets ) {
							$this-&gt;rewrite_module_preset_ids( $shortcode_object, $presets, $presets_rewrite_map );
						} else {
							$this-&gt;apply_global_presets( $shortcode_object, $presets );
						}

						$layouts[ $key ] = et_fb_process_to_shortcode( $shortcode_object, array(), &#039;&#039;, false );
					}

					$step[&#039;data&#039;][&#039;data&#039;] = $layouts;
				}

				$result = $this-&gt;import_layout( $id, $step[&#039;data&#039;], $chunk );

				if ( false === $result ) {
					break;
				}

				if ( $result[&#039;ready&#039;] ) {
					if ( ! isset( $layout_id_map[ $step[&#039;id&#039;] ] ) ) {
						$layout_id_map[ $step[&#039;id&#039;] ] = array();
					}

					// Since a single layout can be duplicated multiple times if
					// it&#039;s global we have to keep an array of duplicated ids.
					$layout_id_map[ $step[&#039;id&#039;] ][ $step[&#039;template_id&#039;] ] = $result[&#039;id&#039;];
				}

				$chunks = $result[&#039;chunks&#039;];
				break;
		}

		$ready = ( $step_index + 1 &gt;= $steps ) &amp;&amp; ( $chunk + 1 &gt;= $chunks );

		return array(
			&#039;ready&#039;         =&gt; $ready,
			&#039;chunks&#039;        =&gt; $chunks,
			&#039;layout_id_map&#039; =&gt; $layout_id_map,
		);
	}

	/**
	 * Download temporary file.
	 *
	 * @since 4.0
	 *
	 * @param string $filename
	 * @param string $temp_file_id
	 * @param string $temp_file
	 * @return void
	 */
	public function download_file( $filename, $temp_file_id, $temp_file ) {
		$this-&gt;prevent_failure();

		$filename = sanitize_file_name( $filename );

		header( &#039;Content-Description: File Transfer&#039; );
		header( &quot;Content-Disposition: attachment; filename=\&quot;{$filename}.json\&quot;&quot; );
		header( &#039;Content-Type: application/json&#039; );
		header( &#039;Pragma: no-cache&#039; );

		if ( file_exists( $temp_file ) ) {
			echo et_core_esc_previously( $this-&gt;get_filesystem()-&gt;get_contents( $temp_file ) );
		}

		$this-&gt;delete_temp_files( &#039;et_core_export&#039;, array( $temp_file_id =&gt; $temp_file ) );

		wp_die();
	}

	/**
	 * Download Export Data.
	 *
	 * @since 2.7.0
	 */
	public function download_export() {
		$this-&gt;prevent_failure();
		et_core_nonce_verified_previously();

		// Retrieve data.
		$timestamp = isset( $_GET[&#039;timestamp&#039;] ) ? sanitize_text_field( $_GET[&#039;timestamp&#039;] ) : null;
		$name = isset( $_GET[&#039;name&#039;] ) ? sanitize_text_field( rawurldecode( $_GET[&#039;name&#039;] ) ) : $this-&gt;instance-&gt;name;
		$filesystem = $this-&gt;set_filesystem();
		$temp_file = $this-&gt;temp_file( sanitize_file_name( $timestamp ), &#039;et_core_export&#039; );

		header( &#039;Content-Description: File Transfer&#039; );
		header( &quot;Content-Disposition: attachment; filename=\&quot;{$name}.json\&quot;&quot; );
		header( &#039;Content-Type: application/json&#039; );
		header( &#039;Pragma: no-cache&#039; );

		if ( file_exists( $temp_file ) ) {
			echo et_core_esc_previously( $filesystem-&gt;get_contents( $temp_file ) );
		}

		$this-&gt;delete_temp_files( &#039;et_core_export&#039; );

		exit;
	}

	protected function to_megabytes( $value ) {
		$unit = strtoupper( substr( $value, -1 ) );
		$amount = intval( substr( $value, 0, -1 ) );

		// Known units
		switch ( $unit ) {
			case &#039;G&#039;: return $amount &lt;&lt; 10;
			case &#039;M&#039;: return $amount;
		}

		if ( is_numeric( $unit ) ) {
			// Numeric unit is present, assume bytes
			return intval( $value ) &gt;&gt; 20;
		}

		// Unknown unit ...
		return intval( $value );

	}// end to_megabytes()

	/**
	 * Get selected posts data.
	 *
	 * @since 2.7.0
	 */
	protected function export_posts_query() {
		et_core_nonce_verified_previously();

		$args = array(
			&#039;post_type&#039;      =&gt; $this-&gt;instance-&gt;target,
			&#039;posts_per_page&#039; =&gt; -1,
			&#039;no_found_rows&#039;  =&gt; true,
		);

		// Only include selected posts if set and not empty.
		if ( isset( $_POST[&#039;selection&#039;] ) ) {
			$include = json_decode( stripslashes( $_POST[&#039;selection&#039;] ), true );

			if ( ! empty( $include ) ) {
				$include = array_map( &#039;intval&#039;, array_values( $include ) );
				$args[&#039;post__in&#039;] = $include;
			}
		}

		$get_posts = get_posts( apply_filters( &quot;et_core_portability_export_wp_query_{$this-&gt;instance-&gt;context}&quot;, $args ) );
		$taxonomies = get_object_taxonomies( $this-&gt;instance-&gt;target );
		$posts = array();

		foreach ( $get_posts as $key =&gt; $post ) {
			unset(
				$post-&gt;post_author,
				$post-&gt;guid
			);

			$posts[$post-&gt;ID] = $post;

			// Include post meta.
			$post_meta = (array) get_post_meta( $post-&gt;ID );

			if ( isset( $post_meta[&#039;_edit_lock&#039;] ) ) {
				unset(
					$post_meta[&#039;_edit_lock&#039;],
					$post_meta[&#039;_edit_last&#039;]
				);
			}

			$posts[$post-&gt;ID]-&gt;post_meta = $post_meta;

			// Include terms.
			$get_terms = (array) wp_get_object_terms( $post-&gt;ID, $taxonomies );
			$terms = array();

			// Order terms to make sure children are after the parents.
			while ( $term = array_shift( $get_terms ) ) {
				if ( 0 === $term-&gt;parent || isset( $terms[$term-&gt;parent] ) ) {
					$terms[$term-&gt;term_id] = $term;
				} else {
					// if parent category is also exporting then add the term to the end of the list and process it later
					// otherwise add a term as usual
					if ( $this-&gt;is_parent_term_included( $get_terms, $term-&gt;parent ) ) {
						$get_terms[] = $term;
					} else {
						$terms[$term-&gt;term_id] = $term;
					}
				}
			}

			$posts[$post-&gt;ID]-&gt;terms = array();

			foreach ( $terms as $term ) {
				$parents_data = array();

				if ( $term-&gt;parent ) {
					$parent_slug = isset( $terms[$term-&gt;parent] ) ? $terms[$term-&gt;parent]-&gt;slug : $this-&gt;get_parent_slug( $term-&gt;parent, $term-&gt;taxonomy );
					$parents_data = $this-&gt;get_all_parents( $term-&gt;parent, $term-&gt;taxonomy );
				} else {
					$parent_slug = 0;
				}

				$posts[$post-&gt;ID]-&gt;terms[$term-&gt;term_id] = array(
					&#039;name&#039;        =&gt; $term-&gt;name,
					&#039;slug&#039;        =&gt; $term-&gt;slug,
					&#039;taxonomy&#039;    =&gt; $term-&gt;taxonomy,
					&#039;parent&#039;      =&gt; $parent_slug,
					&#039;all_parents&#039; =&gt; $parents_data,
					&#039;description&#039; =&gt; $term-&gt;description
				);
			}
		}

		return $posts;
	}

	/**
	 * Check whether the $parent_id included into the $terms_list.
	 *
	 * @since 2.7.0
	 *
	 * @param array $terms_list Array of term objects.
	 * @param int   $parent_id  .
	 *
	 * @return bool
	 */
	protected function is_parent_term_included( $terms_list, $parent_id ) {
		$is_parent_found = false;

		foreach ( $terms_list as $term =&gt; $term_details ) {
			if ( $parent_id === $term_details-&gt;term_id ) {
				$is_parent_found = true;
			}
		}

		return $is_parent_found;
	}

	/**
	 * Retrieve the term slug.
	 *
	 * @since 2.7.0
	 *
	 * @param int    $parent_id .
	 * @param string $taxonomy  .
	 *
	 * @return int|string
	 */
	protected function get_parent_slug( $parent_id, $taxonomy ) {
		$term_data = get_term( $parent_id, $taxonomy );
		$slug = &#039;&#039; === $term_data-&gt;slug ? 0 : $term_data-&gt;slug;

		return $slug;
	}

	/**
	 * Prepare array of all parents so the correct hierarchy can be restored during the import.
	 *
	 * @since 2.7.0
	 *
	 * @param int    $parent_id .
	 * @param string $taxonomy  .
	 *
	 * @return array
	 */
	protected function get_all_parents( $parent_id, $taxonomy ) {
		$parents_data_array = array();
		$parent = $parent_id;

		// retrieve data for all parent categories
		if ( 0 !== $parent  ) {
			while( 0 !== $parent ) {
				$parent_term_data = get_term( $parent, $taxonomy );
				$parents_data_array[$parent_term_data-&gt;slug] = array(
					&#039;name&#039; =&gt; $parent_term_data-&gt;name,
					&#039;description&#039; =&gt; $parent_term_data-&gt;description,
					&#039;parent&#039; =&gt; 0 !== $parent_term_data-&gt;parent ? $this-&gt;get_parent_slug( $parent_term_data-&gt;parent, $taxonomy ) : 0,
				);

				$parent = $parent_term_data-&gt;parent;
			}
		}
		//reverse order of items, to simplify the restoring process
		return array_reverse( $parents_data_array );
	}

	/**
	 * Check if a layout exists in the database already based on both its title and its slug.
	 *
	 * @param string $title
	 * @param string $slug
	 *
	 * @return int $post_id The post id if it exists, zero otherwise.
	 */
	protected static function layout_exists( $title, $slug ) {
		global $wpdb;

		return (int) $wpdb-&gt;get_var( $wpdb-&gt;prepare(
			&quot;SELECT ID FROM $wpdb-&gt;posts WHERE post_title = %s AND post_name = %s&quot;,
			array(
				wp_unslash( sanitize_post_field( &#039;post_title&#039;, $title, 0, &#039;db&#039; ) ),
				wp_unslash( sanitize_post_field( &#039;post_name&#039;, $slug, 0, &#039;db&#039; ) ),
			)
		) );
	}

	/**
	 * Imports Global Presets
	 *
	 * @since 4.0.10 Made public.
	 *
	 * @param array $presets - The Global Presets to be imported
	 *
	 * @return boolean
	 */
	public function import_global_presets( $presets, $is_temp_presets = false ) {
		if ( ! is_array( $presets ) ) {
			return false;
		}

		$all_modules            = ET_Builder_Element::get_modules();
		$module_presets_manager = ET_Builder_Global_Presets_Settings::instance();
		$global_presets         = $module_presets_manager-&gt;get_global_presets();
		$temp_presets           = $module_presets_manager-&gt;get_temp_presets();
		$presets_to_import      = array();

		foreach ( $presets as $module_type =&gt; $module_presets ) {
			$presets_to_import[ $module_type ] = array(
				&#039;presets&#039; =&gt; array(),
			);

			if ( ! isset( $global_presets-&gt;$module_type-&gt;presets ) ) {
				$initial_preset_structure = ET_Builder_Global_Presets_Settings::generate_module_initial_presets_structure( $module_type, $all_modules );

				$global_presets-&gt;$module_type = $initial_preset_structure;
			}

			$local_presets      = $global_presets-&gt;$module_type-&gt;presets;
			$local_preset_names = array();

			foreach ( $local_presets as $preset_id =&gt; $preset ) {
				// Skip temp presets.
				if ( ! isset( $temp_preset[ $module_type ][&#039;presets&#039;][ $preset_id ] ) ) {
					array_push( $local_preset_names, $preset-&gt;name );
				}
			}

			foreach ( $module_presets[&#039;presets&#039;] as $preset_id =&gt; $preset ) {
				$imported_name = sanitize_text_field( $preset[&#039;name&#039;] );
				$name          = in_array( $imported_name, $local_preset_names )
					? $imported_name . &#039; &#039; . esc_html__( &#039;imported&#039;, &#039;et-core&#039; )
					: $imported_name;

				$presets_to_import[ $module_type ][&#039;presets&#039;][ $preset_id ] = array(
					&#039;name&#039;     =&gt; $name,
					&#039;created&#039;  =&gt; time() * 1000,
					&#039;updated&#039;  =&gt; time() * 1000,
					&#039;version&#039;  =&gt; $preset[&#039;version&#039;],
					&#039;settings&#039; =&gt; $preset[&#039;settings&#039;],
				);
			}
		}

		if ( $is_temp_presets ) {
			et_update_option( ET_Builder_Global_Presets_Settings::GLOBAL_PRESETS_OPTION_TEMP, $presets_to_import );
		}

		// Merge existing Global Presets with imported ones
		foreach ( $presets_to_import as $module_type =&gt; $module_presets ) {
			foreach ( $module_presets[&#039;presets&#039;] as $preset_id =&gt; $preset ) {
				$global_presets-&gt;$module_type-&gt;presets-&gt;$preset_id           = (object) array();
				$global_presets-&gt;$module_type-&gt;presets-&gt;$preset_id-&gt;name     = sanitize_text_field( $preset[&#039;name&#039;] );
				$global_presets-&gt;$module_type-&gt;presets-&gt;$preset_id-&gt;created  = $preset[&#039;created&#039;];
				$global_presets-&gt;$module_type-&gt;presets-&gt;$preset_id-&gt;updated  = $preset[&#039;updated&#039;];
				$global_presets-&gt;$module_type-&gt;presets-&gt;$preset_id-&gt;version  = $preset[&#039;version&#039;];
				$global_presets-&gt;$module_type-&gt;presets-&gt;$preset_id-&gt;settings = (object) array();

				foreach ( $preset[&#039;settings&#039;] as $setting_name =&gt; $value ) {
					$setting_name_sanitized = sanitize_text_field( $setting_name );
					$value_sanitized        = sanitize_text_field( $value );

					$global_presets-&gt;$module_type-&gt;presets-&gt;$preset_id-&gt;settings-&gt;$setting_name_sanitized = $value_sanitized;
				}

				// Inject Global colors into imported presets.
				$preset_settings = (array) $global_presets-&gt;$module_type-&gt;presets-&gt;$preset_id-&gt;settings;
				$global_presets-&gt;$module_type-&gt;presets-&gt;$preset_id-&gt;settings = ET_Builder_Global_Presets_Settings::maybe_set_global_colors( $preset_settings );
			}
		}

		// Update option for product setting (last attr in args list).
		et_update_option( ET_Builder_Global_Presets_Settings::GLOBAL_PRESETS_OPTION, $global_presets, false, &#039;&#039;, &#039;&#039;, true );

		if ( ! $is_temp_presets ) {
			$global_presets_history = ET_Builder_Global_Presets_History::instance();
			$global_presets_history-&gt;add_global_history_record( $global_presets );
		}

		return true;
	}

	/**
	 * Import global colors.
	 *
	 * @since 4.9.0
	 *
	 * @param array $incoming_global_colors Global Colors Array.
	 *
	 * @return void
	 */
	public function import_global_colors( $incoming_global_colors ) {
		$global_colors = array();

		foreach ( $incoming_global_colors as $incoming_gcolor ) {
			$key                   = et_()-&gt;sanitize_text_fields( $incoming_gcolor[0] );
			$global_colors[ $key ] = et_()-&gt;sanitize_text_fields( $incoming_gcolor[1] );
		}

		$stored_global_colors = et_builder_get_all_global_colors();

		if ( ! empty( $stored_global_colors ) ) {
			$global_colors = array_merge( $global_colors, $stored_global_colors );
		}

		et_update_option( &#039;et_global_colors&#039;, $global_colors );
	}

	/**
	 * Import post.
	 *
	 * @since 2.7.0
	 *
	 * @param array $posts Array of data formatted by the portability exporter.
	 *
	 * @return bool
	 */
	protected function import_posts( $posts ) {
		/**
		 * Filters the array of builder layouts to import. Returning an empty value will
		 * short-circuit the import process.
		 *
		 * @since 3.0.99
		 *
		 * @param array $posts
		 */
		$posts = apply_filters( &#039;et_core_portability_import_posts&#039;, $posts );

		$imported_posts = array();

		if ( empty( $posts ) ) {
			return false;
		}

		foreach ( $posts as $post ) {
			if ( isset( $post[&#039;post_status&#039;] ) &amp;&amp; &#039;auto-draft&#039; === $post[&#039;post_status&#039;] ) {
				continue;
			}

			$fields_validatation = array(
				&#039;ID&#039;         =&gt; &#039;intval&#039;,
				&#039;post_title&#039; =&gt; &#039;sanitize_text_field&#039;,
				&#039;post_type&#039;  =&gt; &#039;sanitize_text_field&#039;,
			);

			if ( ! $post = $this-&gt;validate( $post, $fields_validatation ) ) {
				continue;
			}

			$layout_exists = self::layout_exists( $post[&#039;post_title&#039;], $post[&#039;post_name&#039;] );

			if ( $layout_exists &amp;&amp; get_post_type( $layout_exists ) === $post[&#039;post_type&#039;] ) {
				// Make sure the post is published.
				if ( &#039;publish&#039; !== get_post_status( $layout_exists ) ) {
					wp_update_post( array(
						&#039;ID&#039;          =&gt; intval( $layout_exists ),
						&#039;post_status&#039; =&gt; &#039;publish&#039;,
					) );
				}

				$imported_posts[] = intval( $layout_exists );

				continue;
			}

			$post[&#039;import_id&#039;] = $post[&#039;ID&#039;];
			unset( $post[&#039;ID&#039;] );

			$post[&#039;post_author&#039;] = (int) get_current_user_id();

			// Insert or update post.
			$post_id = wp_insert_post( $post, true );

			if ( ! $post_id || is_wp_error( $post_id ) ) {
				continue;
			}

			$imported_posts[] = $post_id;

			// Insert and set terms.
			if ( isset( $post[&#039;terms&#039;] ) &amp;&amp; is_array( $post[&#039;terms&#039;] ) ) {
				$processed_terms = array();

				foreach ( $post[&#039;terms&#039;] as $term ) {
					$fields_validatation = array(
						&#039;name&#039;        =&gt; &#039;sanitize_text_field&#039;,
						&#039;slug&#039;        =&gt; &#039;sanitize_title&#039;,
						&#039;taxonomy&#039;    =&gt; &#039;sanitize_title&#039;,
						&#039;parent&#039;      =&gt; &#039;sanitize_title&#039;,
						&#039;description&#039; =&gt; &#039;wp_kses_post&#039;,
					);

					if ( ! $term = $this-&gt;validate( $term, $fields_validatation ) ) {
						continue;
					}

					if ( empty( $term[&#039;parent&#039;] ) ) {
						$parent = 0;
					} else {
						if ( isset( $term[&#039;all_parents&#039;] ) &amp;&amp; ! empty( $term[&#039;all_parents&#039;] ) ) {
							$this-&gt;restore_parent_categories( $term[&#039;all_parents&#039;], $term[&#039;taxonomy&#039;] );
						}

						$parent = term_exists( $term[&#039;parent&#039;], $term[&#039;taxonomy&#039;] );

						if ( is_array( $parent ) ){
							$parent = $parent[&#039;term_id&#039;];
						}
					}

					if ( ! $insert = term_exists( $term[&#039;slug&#039;], $term[&#039;taxonomy&#039;] ) ) {
						$insert = wp_insert_term( $term[&#039;name&#039;], $term[&#039;taxonomy&#039;], array(
							&#039;slug&#039;        =&gt; $term[&#039;slug&#039;],
							&#039;description&#039; =&gt; $term[&#039;description&#039;],
							&#039;parent&#039;      =&gt; intval( $parent ),
						) );
					}

					if ( is_array( $insert ) &amp;&amp; ! is_wp_error( $insert ) ) {
						$processed_terms[$term[&#039;taxonomy&#039;]][] = $term[&#039;slug&#039;];
					}
				}

				// Set post terms.
				foreach ( $processed_terms as $taxonomy =&gt; $ids ) {
					wp_set_object_terms( $post_id, $ids, $taxonomy );
				}
			}

			// Insert or update post meta.
			if ( isset( $post[&#039;post_meta&#039;] ) &amp;&amp; is_array( $post[&#039;post_meta&#039;] ) ) {
				foreach ( $post[&#039;post_meta&#039;] as $meta_key =&gt; $meta ) {

					$meta_key = sanitize_text_field( $meta_key );

					if ( count( $meta ) &lt; 2 ) {
						$meta = wp_kses_post( $meta[0] );
					} else {
						$meta = array_map( &#039;wp_kses_post&#039;, $meta );
					}

					update_post_meta( $post_id, $meta_key, $meta );
				}
			}

			// Assign new thumbnail if provided.
			if ( isset( $post[&#039;thumbnail&#039;] ) ) {
				set_post_thumbnail( $post_id, $post[&#039;thumbnail&#039;] );
			}
		}

		return $imported_posts;
	}

	/**
	 * Restore the categories hierarchy in library.
	 *
	 * @since 2.7.0
	 *
	 * @param array $parents_array    Array of parent categories data.
	 * @param string $taxonomy
	 */
	protected function restore_parent_categories( $parents_array, $taxonomy ) {
		foreach( $parents_array as $slug =&gt; $category_data ) {
			$current_category = term_exists( $slug, $taxonomy );

			if ( ! is_array( $current_category ) ) {
				$parent_id = 0 !== $category_data[&#039;parent&#039;] ? term_exists( $category_data[&#039;parent&#039;], $taxonomy ) : 0;
				wp_insert_term( $category_data[&#039;name&#039;], $taxonomy, array(
					&#039;slug&#039;        =&gt; $slug,
					&#039;description&#039; =&gt; $category_data[&#039;description&#039;],
					&#039;parent&#039;      =&gt; is_array( $parent_id ) ? $parent_id[&#039;term_id&#039;] : $parent_id,
				) );
			} else if ( ( ! isset( $current_category[&#039;parent&#039;] ) || 0 === $current_category[&#039;parent&#039;] ) &amp;&amp; 0 !== $category_data[&#039;parent&#039;] ) {
				$parent_id = 0 !== $category_data[&#039;parent&#039;] ? term_exists( $category_data[&#039;parent&#039;], $taxonomy ) : 0;
				wp_update_term( $current_category[&#039;term_id&#039;], $taxonomy, array( &#039;parent&#039; =&gt; is_array( $parent_id ) ? $parent_id[&#039;term_id&#039;] : $parent_id ) );
			}
		}
	}

	/**
	 * Generates UUIDs for the presets to avoid collisions.
	 *
	 * @since 4.5.0
	 *
	 * @param array $global_presets - The Global Presets to be imported
	 *
	 * @return array - The list of module types for which preset ids have been changed
	 */
	public function prepare_to_import_layout_presets( &amp;$global_presets ) {
		$preset_rewrite_map = array();
		$initial_preset_id = ET_Builder_Global_Presets_Settings::MODULE_INITIAL_PRESET_ID;

		foreach ( $global_presets as $component_type =&gt; &amp;$component_presets ) {
			$preset_rewrite_map[ $component_type ] = array();
			foreach ( $component_presets[&#039;presets&#039;] as $preset_id =&gt; $preset ) {
				$new_id = ET_Core_Data_Utils::uuid_v4();
				$component_presets[&#039;presets&#039;][ $new_id ] = $preset;
				$preset_rewrite_map[ $component_type ][ $preset_id ] = $new_id;
				unset( $component_presets[&#039;presets&#039;][ $preset_id ] );
			}

			if ( $component_presets[&#039;default&#039;] === $initial_preset_id &amp;&amp; ! isset( $preset_rewrite_map[ $component_type ][ $initial_preset_id ] ) ) {
				$new_id = ET_Core_Data_Utils::uuid_v4();
				$component_presets[&#039;default&#039;] = $new_id;
				if ( isset( $component_presets[&#039;presets&#039;][ $initial_preset_id ] ) ) {
					$component_presets[&#039;presets&#039;][ $new_id ] = $component_presets[&#039;presets&#039;][ $initial_preset_id ];
					unset( $component_presets[&#039;presets&#039;][ $initial_preset_id ] );
				}
				$preset_rewrite_map[ $component_type ][ $initial_preset_id ] = $new_id;
			} else {
				$component_presets[&#039;default&#039;] = $preset_rewrite_map[ $component_type ][ $component_presets[&#039;default&#039;] ];
			}
		}

		return $preset_rewrite_map;
	}

	/**
	 * Injects the given Global Presets settings into the imported layout
	 *
	 * @since 4.5.0
	 *
	 * @param array $shortcode_object - The multidimensional array representing a page/module structure
	 * @param array $global_presets - The Global Presets to be imported
	 * @param array $preset_rewrite_map - The list of module types for which preset ids have been changed
	 */
	protected function rewrite_module_preset_ids( &amp;$shortcode_object, $global_presets, $preset_rewrite_map ) {
		$global_presets_manager  = ET_Builder_Global_Presets_Settings::instance();
		$module_preset_attribute = ET_Builder_Global_Presets_Settings::MODULE_PRESET_ATTRIBUTE;

		foreach ( $shortcode_object as &amp;$module ) {
			$module_type      = $global_presets_manager-&gt;maybe_convert_module_type( $module[&#039;type&#039;], $module[&#039;attrs&#039;] );
			$module_preset_id = et_()-&gt;array_get( $module, &quot;attrs.{$module_preset_attribute}&quot;, &#039;default&#039; );

			if ( $module_preset_id === &#039;default&#039; ) {
				$module[&#039;attrs&#039;][ $module_preset_attribute ] = et_()-&gt;array_get( $global_presets, &quot;{$module_type}.default&quot;, &#039;default&#039; );
			} else {
				if ( isset( $preset_rewrite_map[ $module_type ][ $module_preset_id ] ) ) {
					$module[&#039;attrs&#039;][ $module_preset_attribute ] = $preset_rewrite_map[ $module_type ][ $module_preset_id ];
				} else {
					$module[&#039;attrs&#039;][ $module_preset_attribute ] = et_()-&gt;array_get( $global_presets, &quot;{$module_type}.default&quot;, &#039;default&#039; );
				}
			}

			if ( isset( $module[&#039;content&#039;] ) &amp;&amp; is_array( $module[&#039;content&#039;] ) ) {
				$this-&gt;rewrite_module_preset_ids( $module[&#039;content&#039;], $global_presets, $preset_rewrite_map );
			}
		}
	}

	/**
	 * Injects global color ids into the imported layout
	 *
	 * @since 4.10.0
	 *
	 * @param array $data - The multidimensional array representing a import object structure.
	 */
	protected function _maybe_inject_gcid( &amp;$data, &amp;$gcolors = null ) {
		foreach ( $data as $post_id =&gt; &amp;$post_data ) {
			if ( is_array( $post_data ) ) {
				$shortcode_object = et_fb_process_shortcode( $post_data[&#039;post_content&#039;] );
				$this-&gt;_inject_gcid( $shortcode_object, $gcolors );
				$data[ $post_id ][&#039;post_content&#039;] = et_fb_process_to_shortcode( $shortcode_object, array(), &#039;&#039;, false );
			} else {
				$shortcode_object = et_fb_process_shortcode( $post_data );
				$this-&gt;_inject_gcid( $shortcode_object, $gcolors );
				$data[ $post_id ] = et_fb_process_to_shortcode( $shortcode_object, array(), &#039;&#039;, false );
			}
		}

		unset( $post_data );

		return $data;
	}

	/**
	 * Process and inject global color ids into the shortcode
	 *
	 * @since 4.10.0
	 *
	 * @param array $shortcode_object - The multidimensional array representing a page/module structure.
	 */
	protected function _inject_gcid( &amp;$shortcode_object, &amp;$global_colors ) {
		foreach ( $shortcode_object as &amp;$module ) {
			// No global colors set for this module.
			if ( ! empty( $module[&#039;attrs&#039;][&#039;global_colors_info&#039;] ) &amp;&amp; ! empty( $global_colors ) ) {
				$colors_array = json_decode( $module[&#039;attrs&#039;][&#039;global_colors_info&#039;], true );

				if ( ! empty( $colors_array ) ) {
					foreach ( $colors_array as $color_id =&gt; $attrs_array ) {
						if ( ! empty( $attrs_array ) ) {
							// Get settings for this global color.
							$color = &#039;&#039;;
							foreach ( $global_colors as $gcid ) {
								if ( $color_id === $gcid[0] &amp;&amp; &#039;yes&#039; === $gcid[1][&#039;active&#039;] ) {
									$color = $gcid[1][&#039;color&#039;];
								}
							}

							foreach ( $attrs_array as $attr_name ) {
								if ( isset( $module[&#039;attrs&#039;][ $attr_name ] ) &amp;&amp; &#039;&#039; !== $module[&#039;attrs&#039;][ $attr_name ] ) {
									// Match substring (needed for attrs like gradient stops).
									$module[&#039;attrs&#039;][ $attr_name ] = str_replace( $color, $color_id, $module[&#039;attrs&#039;][ $attr_name ] );
								}
							}
						}
					}
				}
			}

			if ( isset( $module[&#039;content&#039;] ) &amp;&amp; is_array( $module[&#039;content&#039;] ) ) {
				$this-&gt;_inject_gcid( $module[&#039;content&#039;], $global_colors );
			}
		}
	}

	/**
	 * Injects the given Global Presets settings into the imported layout
	 *
	 * @since 3.26
	 *
	 * @param array $shortcode_object - The multidimensional array representing a page/module structure
	 * @param array $global_presets   - The Global Presets to be applied
	 */
	protected function apply_global_presets( &amp;$shortcode_object, $global_presets ) {
		$global_presets_manager  = ET_Builder_Global_Presets_Settings::instance();
		$module_preset_attribute = ET_Builder_Global_Presets_Settings::MODULE_PRESET_ATTRIBUTE;

		foreach ( $shortcode_object as &amp;$module ) {
			$module_type = $global_presets_manager-&gt;maybe_convert_module_type( $module[&#039;type&#039;], $module[&#039;attrs&#039;] );

			if ( isset( $global_presets[ $module_type ] ) ) {
				$default_preset_id = et_()-&gt;array_get( $global_presets, &quot;{$module_type}.default&quot;, null );
				$module_preset_id  = et_()-&gt;array_get( $module, &quot;attrs.{$module_preset_attribute}&quot;, $default_preset_id );

				if ( $module_preset_id === &#039;default&#039; ) {
					$module_preset_id = $default_preset_id;
				}

				$preset_settings = array();

				if ( isset( $global_presets[ $module_type ][&#039;presets&#039;][ $module_preset_id ] ) ) {
					$preset_settings = $global_presets[ $module_type ][&#039;presets&#039;][ $module_preset_id ][&#039;settings&#039;];
				} else {
					if ( isset( $global_presets[ $module_type ][&#039;presets&#039;][ $default_preset_id ][&#039;settings&#039;] ) ) {
						$preset_settings = $global_presets[ $module_type ][&#039;presets&#039;][ $default_preset_id ][&#039;settings&#039;];
					}
				}

				$merged_global_colors_info = array();

				if ( isset( $module[&#039;attrs&#039;][&#039;global_colors_info&#039;] ) ) {
					// Retrive global_colors_info from post meta, which saved as string[][].
					$gc_info_prepared = str_replace(
						array( &#039;&amp;#91;&#039;, &#039;&amp;#93;&#039; ),
						array( &#039;[&#039;, &#039;]&#039; ),
						$module[&#039;attrs&#039;][&#039;global_colors_info&#039;]
					);

					$used_global_colors        = json_decode( $gc_info_prepared, true );
					$merged_global_colors_info = $used_global_colors;
				}

				// Merge Global Colors from preset.
				if ( isset( $preset_settings[&#039;global_colors_info&#039;] ) ) {
					$preset_global_colors = json_decode( $preset_settings[&#039;global_colors_info&#039;], true );

					if ( ! empty( $preset_global_colors ) ) {
						foreach ( $preset_global_colors as $color_id =&gt; $settings_list ) {
							if ( ! empty( $settings_list ) ) {
								if ( isset( $used_global_colors[ $color_id ] ) ) {
									$merged_global_colors_info[ $color_id ] = array_merge( $used_global_colors[ $color_id ], $settings_list );
								} else {
									$merged_global_colors_info[ $color_id ] = $settings_list;
								}

								foreach ( $settings_list as $setting_name ) {
									$preset_settings[ $setting_name ] = $color_id;
								}
							}
						}
					}
				}

				$module[&#039;attrs&#039;]                       = array_merge( $preset_settings, $module[&#039;attrs&#039;] );
				$module[&#039;attrs&#039;][&#039;global_colors_info&#039;] = wp_json_encode( $merged_global_colors_info );
			}

			if ( isset( $module[&#039;content&#039;] ) &amp;&amp; is_array( $module[&#039;content&#039;] ) ) {
				$this-&gt;apply_global_presets( $module[&#039;content&#039;], $global_presets );
			}
		}
	}

	/**
	 * Restrict data according the argument registered.
	 *
	 * @since 2.7.0
	 *
	 * @param array  $data   Array of data the query is applied on.
	 * @param string $method Whether data should be set or reset. Accepts &#039;set&#039; or &#039;unset&#039; which is
	 *                       should be used when treating existing data in the db.
	 *
	 * @return array
	 */
	protected function apply_query( $data, $method ) {
		$operator = ( $method === &#039;set&#039; ) ? true : false;

		foreach ( $data as $id =&gt; $value ) {
			if ( ! empty( $this-&gt;instance-&gt;exclude ) &amp;&amp; isset( $this-&gt;instance-&gt;exclude[$id] ) === $operator ) {
				unset( $data[$id] );
			}

			if ( ! empty( $this-&gt;instance-&gt;include ) &amp;&amp; isset( $this-&gt;instance-&gt;include[$id] ) === ! $operator ) {
				unset( $data[$id] );
			}
		}

		return $data;
	}

	/**
	 * Serialize images in chunks.
	 *
	 * @since 4.0
	 *
	 * @param array $images
	 * @param string $method Method applied on images.
	 * @param string $id Unique ID to use for temporary files.
	 * @param integer $chunk
	 *
	 * @return array
	 */
	protected function chunk_images( $images, $method, $id, $chunk = 0 ) {
		$images_per_chunk = 5;
		$chunks           = 1;

		/**
		 * Filters whether or not images in the file being imported should be paginated.
		 *
		 * @since 3.0.99
		 *
		 * @param bool $paginate_images Default `true`.
		 */
		$paginate_images = apply_filters( &#039;et_core_portability_paginate_images&#039;, true );

		if ( $paginate_images &amp;&amp; count( $images ) &gt; $images_per_chunk ) {
			$chunks       = ceil( count( $images ) / $images_per_chunk );
			$slice        = $images_per_chunk * $chunk;
			$images       = array_slice( $images, $slice, $images_per_chunk );
			$images       = $this-&gt;$method( $images );
			$filesystem   = $this-&gt;get_filesystem();
			$temp_file_id = sanitize_file_name( &quot;images_{$id}&quot; );
			$temp_file    = $this-&gt;temp_file( $temp_file_id, &#039;et_core_export&#039; );
			$temp_images  = json_decode( $filesystem-&gt;get_contents( $temp_file ), true );

			if ( is_array( $temp_images ) ) {
				$images = array_merge( $temp_images, $images );
			}

			if ( $chunk + 1 &lt; $chunks ) {
				$filesystem-&gt;put_contents( $temp_file, wp_json_encode( (array) $images ) );
			} else {
				$this-&gt;delete_temp_files( &#039;et_core_export&#039;, array( $temp_file_id =&gt; $temp_file ) );
			}
		} else {
			$images = $this-&gt;$method( $images );
		}

		return array(
			&#039;ready&#039;  =&gt; $chunk + 1 &gt;= $chunks,
			&#039;chunks&#039; =&gt; $chunks,
			&#039;images&#039; =&gt; $images,
		);
	}

	/**
	 * Paginate images processing.
	 *
	 * @since    1.0.0
	 *
	 * @param        $images
	 * @param string $method    Method applied on images.
	 * @param int    $timestamp Timestamp used to store data upon pagination.
	 *
	 * @return array
	 * @internal param array $data Array of images.
	 */
	protected function maybe_paginate_images( $images, $method, $timestamp ) {
		et_core_nonce_verified_previously();

		$page = isset( $_POST[&#039;page&#039;] ) ? (int) $_POST[&#039;page&#039;] : 1;
		$result = $this-&gt;chunk_images( $images, $method, $timestamp, max( $page - 1, 0 ) );

		if ( ! $result[&#039;ready&#039;] ) {
			wp_send_json( array(
				&#039;page&#039;        =&gt; $page,
				&#039;total_pages&#039; =&gt; $result[&#039;chunks&#039;],
				&#039;timestamp&#039;   =&gt; $timestamp,
			) );
		}

		return $result[&#039;images&#039;];
	}

	/**
	 * Get all thumbnail images in the data given.
	 *
	 * @since 4.7.4
	 *
	 * @param array $data Array of data.
	 *
	 * @return array
	 */
	protected function _get_thumbnail_images( $data ) {
		$thumbnails = array();

		foreach ( $data as $post_data ) {
			// If post has thumbnail.
			if ( ! empty( $post_data-&gt;post_meta ) &amp;&amp; ! empty( $post_data-&gt;post_meta-&gt;_thumbnail_id ) ) {
				$post_thumbnail = get_the_post_thumbnail_url( $post_data-&gt;ID );

				// If thumbnail image found in the WP Media library.
				if ( $post_thumbnail ) {
					$thumbnail_id    = (int) $post_data-&gt;post_meta-&gt;_thumbnail_id[0];
					$thumbnail_image = $this-&gt;encode_images( array( $thumbnail_id ) );

					$thumbnails[ $thumbnail_id ] = $thumbnail_image;
				}
			}
		}

		return $thumbnails;
	}

	/**
	 * Get all images in the data given.
	 *
	 * @since 2.7.0
	 *
	 * @param array $data  Array of data.
	 * @param bool  $force Set whether the value should be added by force. Usually used for image ids.
	 *
	 * @return array
	 */
	protected function get_data_images( $data, $force = false ) {
		if ( empty( $data ) ) {
			return array();
		}

		$images     = array();
		$images_src = array();
		$basenames  = array(
			&#039;src&#039;,
			&#039;image_url&#039;,
			&#039;background_image&#039;,
			&#039;image&#039;,
			&#039;url&#039;,
			&#039;bg_img_?\d?&#039;,
		);
		$suffixes  = array(
			&#039;__hover&#039;,
			&#039;_tablet&#039;,
			&#039;_phone&#039;
		);

		foreach ( $basenames as $basename ) {
			$images_src[] = $basename;
			foreach ( $suffixes as $suffix ) {
				$images_src[] = $basename . $suffix;
			}
		}

		foreach ( $data as $value ) {
			// If the $value is an object and there is no post_content property,
			// it&#039;s unlikely to contain any image data so we can continue with the next iteration.
			if ( is_object( $value ) &amp;&amp; ! property_exists( $value, &#039;post_content&#039; ) ) {
				continue;
			}

			if ( is_array( $value ) || is_object( $value ) ) {
				// If the $value contains the post_content property, set $value to use
				// this object&#039;s property value instead of the entire object.
				if ( is_object( $value ) &amp;&amp; property_exists( $value, &#039;post_content&#039; ) ) {
					$value = $value-&gt;post_content;
				}

				$images = array_merge( $images, $this-&gt;get_data_images( (array) $value ) );
				continue;
			}

			// Extract images from HTML or shortcodes.
			if ( preg_match_all( &#039;/(&#039; . implode( &#039;|&#039;, $images_src ) . &#039;)=&quot;(?P&lt;src&gt;\w+[^&quot;]*)&quot;/i&#039;, $value, $matches ) ) {
				foreach ( array_unique( $matches[&#039;src&#039;] ) as $key =&gt; $src ) {
					$images = array_merge( $images, $this-&gt;get_data_images( array( $key =&gt; $src ) ) );
				}
			}

			// Extract images from shortcodes gallery.
			if ( preg_match_all( &#039;/gallery_ids=&quot;(?P&lt;ids&gt;\w+[^&quot;]*)&quot;/i&#039;, $value, $matches ) ) {
				foreach ( array_unique( $matches[&#039;ids&#039;] ) as $galleries ) {
					$explode = explode( &#039;,&#039;, str_replace( &#039; &#039;, &#039;&#039;, $galleries ) );

					foreach ( $explode as $image_id ) {
						$images = array_merge( $images, $this-&gt;get_data_images( array( (int) $image_id ), true ) );
					}
				}
			}

			if ( preg_match( &#039;/^.+?\.(jpg|jpeg|jpe|png|gif|svg|webp)/&#039;, $value, $match ) || $force ) {
				$basename = basename( $value );

				// Skip if the value is not a valid URL or an image ID (integer).
				if ( ! ( wp_http_validate_url( $value ) || is_int( $value ) ) ) {
					continue;
				}

				// Skip if the images array already contains the value to avoid duplicates.
				if ( isset( $images[$value] ) ) {
					continue;
				}

				$images[$value] = $value;
			}
		}

		return $images;
	}

	/**
	 * Get the attachment post id for the given url.
	 *
	 * @since 3.22.3
	 *
	 * @param string $url The url of an attachment file.
	 *
	 * @return int
	 */
	protected function _get_attachment_id_by_url( $url ) {
		global $wpdb;

		// Remove any thumbnail size suffix from the filename and use that as a fallback.
		$fallback_url = preg_replace( &#039;/-\d+x\d+(\.[^.]+)$/i&#039;, &#039;$1&#039;, $url );

		// 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 )
			ORDER BY CHAR_LENGTH( `guid` ) DESC
		&quot;, &#039;attachment&#039;, esc_url_raw( $url ), esc_url_raw( $fallback_url ) );

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

		return $attachment_id;
	}

	/**
	 * Encode image in a base64 format.
	 *
	 * @since 2.7.0
	 *
	 * @param array $images Array of data for which images need to be encoded if any.
	 *
	 * @return array
	 */
	protected function encode_images( $images ) {
		$encoded = array();

		foreach ( $images as $url ) {
			$id = 0;
			$image = &#039;&#039;;

			if ( is_int( $url ) ) {
				$id = $url;
				$url = wp_get_attachment_url( $id );
			} else {
				$id = $this-&gt;_get_attachment_id_by_url( $url );
			}

			if ( $id &gt; 0 ) {
				$image = $this-&gt;_encode_attachment_image( $id );
			}

			if ( empty( $image ) ) {
				// Case 1: No attachment found.
				// Case 2: Attachment found, but file does not exist (may be stored on a CDN, for example).
				$image = $this-&gt;_encode_remote_image( $url );
			}

			if ( empty( $image ) ) {
				// All fetching methods have failed - bail on encoding.
				continue;
			}

			$encoded[ $url ] = array(
				&#039;encoded&#039; =&gt; $image,
				&#039;url&#039;     =&gt; $url,
			);

			// Add image id for replacement purposes.
			if ( $id &gt; 0 ) {
				$encoded[ $url ][&#039;id&#039;] = $id;
			}
		}

		return $encoded;
	}

	/**
	 * Encode an image attachment.
	 *
	 * @since 3.22.3
	 *
	 * @param int $id
	 *
	 * @return string
	 */
	protected function _encode_attachment_image( $id ) {
		/**
		 * @var WP_Filesystem_Base $wp_filesystem
		 */
		global $wp_filesystem;

		if ( ! current_user_can( &#039;read_post&#039;, $id ) ) {
			return &#039;&#039;;
		}

		$file = get_attached_file( $id );

		if ( ! $wp_filesystem-&gt;exists( $file ) ) {
			return &#039;&#039;;
		}

		$image = $wp_filesystem-&gt;get_contents( $file );

		if ( empty( $image ) ) {
			return &#039;&#039;;
		}

		return base64_encode( $image );
	}

	/**
	 * Encode a remote image.
	 *
	 * @since 3.22.3
	 *
	 * @param string $url
	 *
	 * @return string
	 */
	protected function _encode_remote_image( $url ) {
		$request = wp_remote_get( esc_url_raw( $url ), array(
			&#039;timeout&#039;     =&gt; 2,
			&#039;redirection&#039; =&gt; 2,
		) );

		if ( ! is_array( $request ) || is_wp_error( $request ) ) {
			return &#039;&#039;;
		}

		if ( ! self::$_-&gt;includes( $request[&#039;headers&#039;][&#039;content-type&#039;], &#039;image&#039; ) ) {
			return &#039;&#039;;
		}

		$image = wp_remote_retrieve_body( $request );

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

		return base64_encode( $image );
	}

	/**
	 * Decode base64 formatted image and upload it to WP media.
	 *
	 * @since 2.7.0
	 *
	 * @param array $images Array of encoded images which needs to be uploaded.
	 *
	 * @return array
	 */
	protected function upload_images( $images ) {
		$filesystem = $this-&gt;set_filesystem();

		/**
		 * Filters whether or not to allow duplicate images to be uploaded
		 * during Portability import.
		 *
		 * @since 4.14.8
		 *
		 * @param bool $allow_duplicates Whether or not to allow duplicates. Default is `false`.
		 */
		$allow_duplicates = apply_filters( &#039;et_core_portability_import_attachment_allow_duplicates&#039;, false );

		foreach ( $images as $key =&gt; $image ) {
			$basename = sanitize_file_name( wp_basename( $image[&#039;url&#039;] ) );
			$id       = 0;
			$url      = &#039;&#039;;

			if ( ! $allow_duplicates ) {
				$attachments = get_posts( array(
					&#039;posts_per_page&#039; =&gt; -1,
					&#039;post_type&#039;      =&gt; &#039;attachment&#039;,
					&#039;meta_key&#039;       =&gt; &#039;_wp_attached_file&#039;,
					&#039;meta_value&#039;     =&gt; pathinfo( $basename, PATHINFO_FILENAME ),
					&#039;meta_compare&#039;   =&gt; &#039;LIKE&#039;,
				) );

				// Avoid duplicates.
				if ( ! is_wp_error( $attachments ) &amp;&amp; ! empty( $attachments ) ) {
					foreach ( $attachments as $attachment ) {
						$attachment_url = wp_get_attachment_url( $attachment-&gt;ID );
						$file           = get_attached_file( $attachment-&gt;ID );
						$filename       = sanitize_file_name( wp_basename( $file ) );

						// Use existing image only if the content matches.
						if ( $filesystem-&gt;get_contents( $file ) === base64_decode( $image[&#039;encoded&#039;] ) ) {
							$id  = isset( $image[&#039;id&#039;] ) ? $attachment-&gt;ID : 0;
							$url = $attachment_url;

							break;
						}
					}
				}
			}

			// Create new image.
			if ( empty( $url ) ) {
				$temp_file = wp_tempnam();
				$filesystem-&gt;put_contents( $temp_file, base64_decode( $image[&#039;encoded&#039;] ) );
				$filetype = wp_check_filetype_and_ext( $temp_file, $basename );

				if ( ! $allow_duplicates &amp;&amp; ! empty( $attachments ) &amp;&amp; ! is_wp_error( $attachments ) ) {
					// Avoid further duplicates if the proper_filename matches an existing image.
					if ( isset( $filetype[&#039;proper_filename&#039;] ) &amp;&amp; $filetype[&#039;proper_filename&#039;] !== $basename ) {
						foreach ( $attachments as $attachment ) {
							$attachment_url = wp_get_attachment_url( $attachment-&gt;ID );
							$file           = get_attached_file( $attachment-&gt;ID );
							$filename       = sanitize_file_name( wp_basename( $file ) );

							if ( isset( $filename ) &amp;&amp; $filename === $filetype[&#039;proper_filename&#039;] ) {
								// Use existing image only if the basenames and content match.
								if ( $filesystem-&gt;get_contents( $file ) === $filesystem-&gt;get_contents( $temp_file ) ) {
									$id  = isset( $image[&#039;id&#039;] ) ? $attachment-&gt;ID : 0;
									$url = $attachment_url;

									$filesystem-&gt;delete( $temp_file );

									break;
								}
							}
						}
					}
				}

				$file = array(
					&#039;name&#039;     =&gt; $basename,
					&#039;tmp_name&#039; =&gt; $temp_file,
				);


				$upload        = media_handle_sideload( $file );
				$attachment_id = is_wp_error( $upload ) ? 0 : $upload;

				/**
				 * Fires when image attachments are created during portability import.
				 *
				 * @since 4.14.6
				 *
				 * @param int $attachment_id The attachment id or 0 if attachment upload failed.
				 */
				do_action( &#039;et_core_portability_import_attachment_created&#039;, $attachment_id );

				if ( ! is_wp_error( $upload ) ) {
					// Set the replacement as an id if the original image was set as an id (for gallery).
					$id = isset( $image[&#039;id&#039;] ) ? $upload : 0;
					$url = wp_get_attachment_url( $upload );
				} else {
					// Make sure the temporary file is removed if media_handle_sideload didn&#039;t take care of it.
					$filesystem-&gt;delete( $temp_file );
				}
			}

			// Only declare the replace if a url is set.
			if ( $id &gt; 0 ) {
				$images[$key][&#039;replacement_id&#039;] = $id;
			}

			if ( ! empty( $url ) ) {
				$images[$key][&#039;replacement_url&#039;] = $url;
			}

			unset( $url );
		}

		return $images;
	}

	/**
	 * Replace encoded image url with a real url
	 *
	 * @param $subject     - The string to perform replacing for
	 * @param array $image - The image settings
	 *
	 * @return string|string[]|null
	 */
	protected function replace_image_url( $subject, $image ) {
		if ( isset( $image[&#039;replacement_id&#039;] ) &amp;&amp; isset( $image[&#039;id&#039;] ) ) {
			$search      = $image[&#039;id&#039;];
			$replacement = $image[&#039;replacement_id&#039;];
			$subject     = preg_replace( &quot;/(gallery_ids=.*){$search}(.*\&quot;)/&quot;, &quot;\${1}{$replacement}\${2}&quot;, $subject );
		}

		if ( isset( $image[&#039;url&#039;] ) &amp;&amp; isset( $image[&#039;replacement_url&#039;] ) &amp;&amp; $image[&#039;url&#039;] !== $image[&#039;replacement_url&#039;] ) {
			$search      = $image[&#039;url&#039;];
			$replacement = $image[&#039;replacement_url&#039;];
			$subject     = str_replace( $search, $replacement, $subject );
		}

		return $subject;
	}

	/**
	 * Replace image urls with newly uploaded images.
	 *
	 * @since 2.7.0
	 *
	 * @param array $images Array of new images uploaded.
	 * @param array $data   Array of for which images url needs to be replaced.
	 *
	 * @return array|mixed|object
	 */
	protected function replace_images_urls( $images, $data ) {
		foreach ( $data as $post_id =&gt; &amp;$post_data ) {
			foreach ( $images as $image ) {
				if ( is_array( $post_data ) ) {
					foreach ( $post_data as $post_param =&gt; &amp;$param_value ) {
						if ( ! is_array( $param_value ) ) {
							$data[ $post_id ][ $post_param ] = $this-&gt;replace_image_url( $param_value, $image );
						}
					}
					unset($param_value);
				} else {
					$data[ $post_id ] = $this-&gt;replace_image_url( $post_data, $image );
				}
			}
		}
		unset($post_data);

		return $data;
	}

	/**
	 * Validate data and remove any malicious code.
	 *
	 * @since 2.7.0
	 *
	 * @param array $data              Array of data which needs to be validated.
	 * @param array $fields_validation Array of field and validation callback.
	 *
	 * @return array|bool
	 */
	protected function validate( $data, $fields_validation = array() ) {
		if ( ! is_array( $data ) ) {
			return false;
		}

		foreach ( $data as $key =&gt; $value ) {
			if ( is_array( $value ) ) {
				$data[$key] = $this-&gt;validate( $value, $fields_validation );
			} else {
				if ( isset( $fields_validation[$key] ) ) {
					// @phpcs:ignore Generic.PHP.ForbiddenFunctions.Found
					$data[$key] = call_user_func( $fields_validation[$key], $value );
				} else {
					if ( current_user_can( &#039;unfiltered_html&#039; ) ) {
						$data[ $key ] = $value;
					} else {
						$data[ $key ] = wp_kses_post( $value );
					}
				}
			}
		}

		return $data;
	}

	/**
	 * Filters a variable with string filter
	 *
	 * @param mixed $data - Value to filter.
	 *
	 * @return mixed
	 */
	protected function _filter_post_data( $data ) {
		return filter_var( $data, FILTER_SANITIZE_STRING, FILTER_FLAG_NO_ENCODE_QUOTES );
	}

	/**
	 * Prevent import and export timeout or memory failure.
	 *
	 * @since 2.7.0
	 *
	 * It doesn&#039;t need to be reset as in both case the request exit.
	 */
	protected function prevent_failure() {
		@set_time_limit( 0 );

		// Increase memory which is safe at this stage of the request.
		if ( et_core_get_memory_limit() &lt; 256 ) {
			@ini_set( &#039;memory_limit&#039;, &#039;256M&#039; );
		}
	}

	/**
	 * Set WP filesystem to direct. This should only be use to create a temporary file.
	 *
	 * @since 2.7.0
	 *
	 * It is safe to do so since the created file is removed immediately after import. The method does&#039;nt have
	 * to be reset since the ajax query is exited.
	 */
	protected function set_filesystem() {
		global $wp_filesystem;

		add_filter( &#039;filesystem_method&#039;, array( $this, &#039;replace_filesystem_method&#039; ) );
		WP_Filesystem();

		return $wp_filesystem;
	}

	/**
	 * Proxy method for set_filesystem() to avoid calling it multiple times.
	 *
	 * @since 4.0
	 *
	 * @return WP_Filesystem_Direct
	 */
	protected function get_filesystem() {
		static $filesystem = null;

		if ( null === $filesystem ) {
			$filesystem = $this-&gt;set_filesystem();
		}

		return $filesystem;
	}

	/**
	 * Check if a temporary file is register. Returns temporary file if it exists.
	 *
	 * @since 4.0 Made method public.
	 *
	 * @param string $id    Unique id used when the temporary file was created.
	 * @param string $group Group name in which files are grouped.
	 *
	 * @return bool|string
	 */
	public function has_temp_file( $id, $group ) {
		$temp_files = get_option( &#039;_et_core_portability_temp_files&#039;, array() );

		if ( isset( $temp_files[$group][$id] ) &amp;&amp; file_exists( $temp_files[$group][$id] ) ) {
			return $temp_files[$group][$id];
		}

		return false;
	}

	/**
	 * Create a temp file and register it.
	 *
	 * @since 2.7.0
	 * @since 4.0 Made method public. Added $content parameter.
	 *
	 * @param string      $id        Unique id reference for the temporary file.
	 * @param string      $group     Group name in which files are grouped.
	 * @param string|bool $temp_file Path to the temporary file. False create a new temporary file.
	 *
	 * @return bool|string
	 */
	public function temp_file( $id, $group, $temp_file = false, $content = &#039;&#039; ) {
		$temp_files = get_option( &#039;_et_core_portability_temp_files&#039;, array() );

		if ( ! isset( $temp_files[$group] ) ) {
			$temp_files[$group] = array();
		}

		if ( isset( $temp_files[$group][$id] ) &amp;&amp; file_exists( $temp_files[$group][$id] ) ) {
			return $temp_files[$group][$id];
		}

		$temp_file = $temp_file ? $temp_file : wp_tempnam();
		$temp_files[$group][$id] = $temp_file;

		update_option( &#039;_et_core_portability_temp_files&#039;, $temp_files, false );

		if ( ! empty( $content ) ) {
			$this-&gt;get_filesystem()-&gt;put_contents( $temp_file, $content );
		}

		return $temp_file;
	}

	/**
	 * Get temp file contents or an empty string if it does not exist.
	 *
	 * @since 4.0
	 *
	 * @param string $id    Unique id used when the temporary file was created.
	 * @param string $group Group name in which files are grouped.
	 *
	 * @return string
	 */
	public function get_temp_file_contents( $id, $group ) {
		$file = $this-&gt;has_temp_file( $id, $group );

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

		$content = $this-&gt;get_filesystem()-&gt;get_contents( $file );

		return $content ? $content : &#039;&#039;;
	}

	/**
	 * Delete all the temp files.
	 *
	 * @since 2.7.0
	 *
	 * @param bool|string $group         Group name in which files are grouped. Set to true to remove all groups and files.
	 * @param array       $defined_files Array or temoporary files to delete. No argument deletes all temp files.
	 */
	public function delete_temp_files( $group = false, $defined_files = false ) {
		$filesystem = $this-&gt;set_filesystem();
		$temp_files = get_option( &#039;_et_core_portability_temp_files&#039;, array() );

		// Remove all temp files accross all groups if group is true.
		if ( $group === true ) {
			foreach( $temp_files as $group_id =&gt; $_group ) {
				$this-&gt;delete_temp_files( $group_id );
			}
		}

		if ( ! isset( $temp_files[$group] ) ) {
			return;
		}

		$delete_files = ( is_array( $defined_files ) &amp;&amp; ! empty( $defined_files ) ) ? $defined_files : $temp_files[$group];

		foreach ( $delete_files as $id =&gt; $temp_file ) {
			if ( isset( $temp_files[$group][$id] ) &amp;&amp; $filesystem-&gt;delete( $temp_files[$group][$id] ) ) {
				unset( $temp_files[$group][$id] );
			}
		}

		if ( empty( $temp_files[$group] ) ) {
			unset( $temp_files[$group] );
		}

		if ( empty( $temp_files ) ) {
			delete_option( &#039;_et_core_portability_temp_files&#039; );
		} else {
			update_option( &#039;_et_core_portability_temp_files&#039;, $temp_files, false );
		}
	}

	/**
	 * Set WP filesystem method to direct.
	 *
	 * @since 2.7.0
	 */
	public function replace_filesystem_method() {
		return &#039;direct&#039;;
	}

	/**
	 * Get timestamp or create one if it isn&#039;t set.
	 *
	 * @since 2.7.0
	 */
	public function get_timestamp() {
		et_core_nonce_verified_previously();

		if ( isset( $_POST[&#039;timestamp&#039;] ) &amp;&amp; ! empty( $_POST[&#039;timestamp&#039;] ) ) {
			return sanitize_text_field( $_POST[&#039;timestamp&#039;] );
		}

		return function_exists( &#039;hrtime&#039; ) ? (string) hrtime( true ) : (string) microtime( true ); // phpcs:ignore PHPCompatibility.FunctionUse.NewFunctions.hrtimeFound -- Intentional use of new PHP function
	}

	/**
	 * Get Global Colors array from provided global_colors_info.
	 *
	 * @since 4.10.8
	 *
	 * @param array $global_colors_info Array of global colors to process.
	 *
	 * @return array The list of the Global Colors for export.
	 */
	protected function _get_global_colors_data( $global_colors_info = array() ) {
		$global_color_ids = array_unique( array_keys( $global_colors_info ) );

		if ( empty( $global_color_ids ) ) {
			return array();
		}

		$all_global_colors = et_builder_get_all_global_colors();
		$used_colors       = array();

		foreach ( $global_color_ids as $color_id ) {
			if ( isset( $all_global_colors[ $color_id ] ) ) {
				$color_data = array(
					$color_id,
					$all_global_colors[ $color_id ],
				);

				$used_colors[] = $color_data;
			}
		}

		return $used_colors;
	}

	/**
	 * Get List of global colors used in shortcode.
	 *
	 * @since 4.10.8
	 *
	 * @param array $shortcode_object   The multidimensional array representing a page structure.
	 * @param array $used_global_colors List of global colors to merge with.
	 * @param array $presets            Object of presets.
	 *
	 * @return array - The list of the Global Colors.
	 */
	protected function _get_used_global_colors( $shortcode_object, $used_global_colors = array(), $presets = array() ) {
		foreach ( $shortcode_object as $module ) {
			if ( isset( $module[&#039;attrs&#039;][&#039;global_colors_info&#039;] ) ) {
				// Retrive global_colors_info from post meta, which saved as string[][].
				$gc_info_prepared   = str_replace(
					array( &#039;&amp;#91;&#039;, &#039;&amp;#93;&#039; ),
					array( &#039;[&#039;, &#039;]&#039; ),
					$module[&#039;attrs&#039;][&#039;global_colors_info&#039;]
				);

				// Make sure we pass array to array_merge to avoid Fatal Error.
				$gc_info_array      = json_decode( $gc_info_prepared, true );
				$gc_info_array      = is_array( $gc_info_array ) ? $gc_info_array : [];
				$used_global_colors = array_merge( $used_global_colors, $gc_info_array );
			}

			if ( isset( $module[&#039;content&#039;] ) &amp;&amp; is_array( $module[&#039;content&#039;] ) ) {
				$used_global_colors = array_merge( $used_global_colors, $this-&gt;_get_used_global_colors( $module[&#039;content&#039;], $used_global_colors, $presets ) );
			}
		}

		if ( ! empty( $presets ) ) {
			foreach ( $presets as $module_type =&gt; $module_presets ) {
				foreach ( $module_presets-&gt;presets as $preset_id =&gt; $preset ) {
					if ( isset( $preset-&gt;settings-&gt;global_colors_info ) ) {
						$used_global_colors = array_merge( $used_global_colors, json_decode( $preset-&gt;settings-&gt;global_colors_info, true ) );
					}
				}
			}
		}

		return $used_global_colors;
	}

	/**
	 * Returns Global Presets used for a given shortcode only
	 *
	 * @since 3.26
	 *
	 * @param array $shortcode_object - The multidimensional array representing a page structure
	 * @param array $used_global_presets
	 *
	 * @return array - The list of the Global Presets
	 *
	 */
	protected function get_used_global_presets( $shortcode_object, $used_global_presets = array() ) {
		$global_presets_manager = ET_Builder_Global_Presets_Settings::instance();

		foreach ( $shortcode_object as $module ) {
			$module_type = $global_presets_manager-&gt;maybe_convert_module_type( $module[&#039;type&#039;], $module[&#039;attrs&#039;] );
			$preset_id   = $global_presets_manager-&gt;get_module_preset_id( $module_type, $module[&#039;attrs&#039;] );
			$preset      = $global_presets_manager-&gt;get_module_preset( $module_type, $preset_id );

			if ( $preset_id !== &#039;default&#039; &amp;&amp; count( (array) $preset ) !== 0 &amp;&amp; count( (array) $preset-&gt;settings ) !== 0 ) {
				if ( ! isset( $used_global_presets[ $module_type ] ) ) {
					$used_global_presets[ $module_type ] = (object) array(
						&#039;presets&#039; =&gt; (object) array(),
					);
				}

				if ( ! isset( $used_global_presets[ $module_type ]-&gt;presets-&gt;$preset_id ) ) {
					$used_global_presets[ $module_type ]-&gt;presets-&gt;$preset_id = (object) array(
						&#039;name&#039;     =&gt; $preset-&gt;name,
						&#039;version&#039;  =&gt; $preset-&gt;version,
						&#039;settings&#039; =&gt; $preset-&gt;settings,
					);
				}

				if ( ! isset( $used_global_presets[ $module_type ]-&gt;default ) ) {
					$used_global_presets[ $module_type ]-&gt;default = $global_presets_manager-&gt;get_module_default_preset_id( $module_type );
				}
			}

			if ( isset( $module[&#039;content&#039;] ) &amp;&amp; is_array( $module[&#039;content&#039;] ) ) {
				$used_global_presets = array_merge( $used_global_presets, $this-&gt;get_used_global_presets( $module[&#039;content&#039;], $used_global_presets ) );
			}
		}

		return $used_global_presets;
	}

	/**
	 * Returns Global Colors used for a given theme builder shortcode.
	 *
	 * @since 4.18.0
	 *
	 * @param array $shortcode_object - The multidimensional array representing a page structure.
	 *
	 * @return array The list of the Global Colors
	 */
	public function get_theme_builder_library_used_global_colors( $shortcode_object ) {
		return $this-&gt;_get_used_global_colors( $shortcode_object );
	}

	/**
	 * Returns Global Presets used for a given theme builder shortcode.
	 *
	 * @since 4.18.0
	 *
	 * @param array $shortcode_object - The multidimensional array representing a page structure.
	 *
	 * @return array The list of the Global Presets
	 */
	public function get_theme_builder_library_used_global_presets( $shortcode_object ) {
		return $this-&gt;get_used_global_presets( $shortcode_object );
	}

	/**
	 * Returns images used for a given theme builder shortcode.
	 *
	 * @since 4.18.0
	 *
	 * @param array $data - ID and Post content.
	 *
	 * @return array The list of the encoded images
	 */
	public function get_theme_builder_library_images( $data ) {
		$timestamp = $this-&gt;get_timestamp();
		$images    = $this-&gt;get_data_images( $data );

		return $this-&gt;maybe_paginate_images( $images, &#039;encode_images&#039;, $timestamp );
	}

	/**
	 * Returns thumbnails used for a given theme builder shortcode.
	 *
	 * @since 4.18.0
	 *
	 * @param array $data - ID and Post content.
	 *
	 * @return array The list of the thumbnails
	 */
	public function get_theme_builder_library_thumbnail_images( $data ) {
		return $this-&gt;_get_thumbnail_images( $data );
	}

	/**
	 * Enqueue assets.
	 *
	 * @since ?.? Script `et-core-portability` now loads in footer along with `et-core-admin`.
	 * @since 2.7.0
	 */
	public function assets() {
		$time = &#039;&lt;span&gt;1&lt;/span&gt;&#039;;

		wp_enqueue_style( &#039;et-core-portability&#039;, ET_CORE_URL . &#039;admin/css/portability.css&#039;, array(
			&#039;et-core-admin&#039;,
		), ET_CORE_VERSION );

		wp_enqueue_script(
			&#039;et-core-portability&#039;,
			ET_CORE_URL . &#039;admin/js/portability.js&#039;,
			array(
				&#039;jquery&#039;,
				&#039;jquery-ui-tabs&#039;,
				&#039;jquery-form&#039;,
				&#039;et-core-admin&#039;,
			),
			ET_CORE_VERSION,
			true
		);

		wp_localize_script( &#039;et-core-portability&#039;, &#039;etCorePortability&#039;, array(
			&#039;nonces&#039;        =&gt; array(
				&#039;import&#039; =&gt; wp_create_nonce( &#039;et_core_portability_import&#039; ),
				&#039;export&#039; =&gt; wp_create_nonce( &#039;et_core_portability_export&#039; ),
				&#039;cancel&#039; =&gt; wp_create_nonce( &#039;et_core_portability_cancel&#039; ),
			),
			&#039;postMaxSize&#039;   =&gt; $this-&gt;to_megabytes( @ini_get( &#039;post_max_size&#039; ) ),
			&#039;uploadMaxSize&#039; =&gt; $this-&gt;to_megabytes( @ini_get( &#039;upload_max_filesize&#039; ) ),
			&#039;text&#039;          =&gt; array(
				// phpcs:disable WordPress.WP.I18n.NonSingularStringLiteralDomain -- Following the standard.
				&#039;browserSupport&#039;    =&gt; esc_html__( &#039;The browser version you are currently using is outdated. Please update to the newest version.&#039;, ET_CORE_TEXTDOMAIN ),
				&#039;memoryExhausted&#039;   =&gt; esc_html__( &#039;You reached your server memory limit. Please try increasing your PHP memory limit.&#039;, ET_CORE_TEXTDOMAIN ),
				&#039;maxSizeExceeded&#039;   =&gt; esc_html__( &#039;This file cannot be imported. It may be caused by file_uploads being disabled in your php.ini. It may also be caused by post_max_size or/and upload_max_filesize being smaller than file selected. Please increase it or transfer more substantial data at the time.&#039;, ET_CORE_TEXTDOMAIN ),
				&#039;invalideFile&#039;      =&gt; esc_html__( &#039;Invalid File format. You should be uploading a JSON file.&#039;, ET_CORE_TEXTDOMAIN ),
				&#039;importContextFail&#039; =&gt; esc_html__( &#039;This file should not be imported in this context.&#039;, ET_CORE_TEXTDOMAIN ),
				&#039;noItemsSelected&#039;   =&gt; esc_html__( &#039;Please select at least one item to export or disable the &quot;Only export selected items&quot; option&#039;, ET_CORE_TEXTDOMAIN ),
				&#039;noItemsToExport&#039;   =&gt; esc_html__( &#039;There are no items to export.&#039;, ET_CORE_TEXTDOMAIN ),
				&#039;importing&#039;         =&gt; sprintf( esc_html__( &#039;Import estimated time remaining: %smin&#039;, ET_CORE_TEXTDOMAIN ), $time ),
				&#039;exporting&#039;         =&gt; sprintf( esc_html__( &#039;Export estimated time remaining: %smin&#039;, ET_CORE_TEXTDOMAIN ), $time ),
				&#039;backuping&#039;         =&gt; sprintf( esc_html__( &#039;Backup estimated time remaining: %smin&#039;, ET_CORE_TEXTDOMAIN ), $time ),
				// phpcs:enable
			),
		) );
	}

	/**
	 * Modal HTML.
	 *
	 * @since 2.7.0
	 */
	public function modal() {
		$export_url = add_query_arg( array(
			&#039;et_core_portability&#039; =&gt; true,
			&#039;context&#039;             =&gt; $this-&gt;instance-&gt;context,
			&#039;name&#039;                =&gt; $this-&gt;instance-&gt;name,
			&#039;nonce&#039;               =&gt; wp_create_nonce( &#039;et_core_portability_export&#039; ),

		), admin_url() );

		$is_etdev_plugin_activated = is_plugin_active( &#039;etdev/etdev.php&#039; );

		// phpcs:disable WordPress.WP.I18n.NonSingularStringLiteralDomain -- Existing codebase.
		?&gt;
		&lt;div class=&quot;et-core-modal-overlay et-core-form&quot; data-et-core-portability=&quot;&lt;?php echo esc_attr( $this-&gt;instance-&gt;context ); ?&gt;&quot;&gt;
			&lt;div class=&quot;et-core-modal&quot;&gt;
				&lt;div class=&quot;et-core-modal-header&quot;&gt;
					&lt;h3 class=&quot;et-core-modal-title&quot;&gt;&lt;?php echo esc_html( $this-&gt;instance-&gt;title ); ?&gt;&lt;/h3&gt;&lt;a href=&quot;#&quot; class=&quot;et-core-modal-close&quot; data-et-core-modal=&quot;close&quot;&gt;&lt;/a&gt;
				&lt;/div&gt;
				&lt;div data-et-core-tabs class=&quot;et-core-modal-tabs-enabled&quot;&gt;
					&lt;ul class=&quot;et-core-tabs&quot;&gt;
						&lt;li&gt;&lt;a href=&quot;#et-core-portability-export&quot;&gt;&lt;?php esc_html_e( &#039;Export&#039;, ET_CORE_TEXTDOMAIN ); ?&gt;&lt;/a&gt;&lt;/li&gt;
						&lt;li&gt;&lt;a href=&quot;#et-core-portability-import&quot;&gt;&lt;?php esc_html_e( &#039;Import&#039;, ET_CORE_TEXTDOMAIN ); ?&gt;&lt;/a&gt;&lt;/li&gt;
					&lt;/ul&gt;
					&lt;div id=&quot;et-core-portability-export&quot;&gt;
						&lt;div class=&quot;et-core-modal-content&quot;&gt;
							&lt;?php printf( esc_html__( &#039;Exporting your %s will create a JSON file that can be imported into a different website.&#039;, ET_CORE_TEXTDOMAIN ), esc_html( $this-&gt;instance-&gt;name ) ); ?&gt;
							&lt;h3&gt;&lt;?php esc_html_e( &#039;Export File Name&#039;, ET_CORE_TEXTDOMAIN ); ?&gt;&lt;/h3&gt;
							&lt;form class=&quot;et-core-portability-export-form&quot;&gt;
								&lt;input type=&quot;text&quot; name=&quot;&quot; value=&quot;&lt;?php echo esc_attr( $this-&gt;instance-&gt;name ); ?&gt;&quot;&gt;
								&lt;?php if ( &#039;post_type&#039; === $this-&gt;instance-&gt;type ) : ?&gt;
									&lt;div class=&quot;et-core-clearfix&quot;&gt;&lt;/div&gt;
									&lt;label&gt;&lt;input type=&quot;checkbox&quot; name=&quot;et-core-portability-posts&quot; &lt;?php echo $is_etdev_plugin_activated ? &#039;checked&#039; : &#039;&#039;; ?&gt; /&gt;&lt;?php esc_html_e( &#039;Only export selected items&#039;, ET_CORE_TEXTDOMAIN ); ?&gt;&lt;/label&gt;
								&lt;?php endif; ?&gt;
								&lt;?php if ( $is_etdev_plugin_activated ) : ?&gt;
									&lt;div class=&quot;et-core-clearfix&quot;&gt;&lt;/div&gt;
									&lt;label&gt;&lt;input type=&quot;checkbox&quot; name=&quot;et-core-portability-apply-presets&quot; checked /&gt;&lt;?php esc_html_e( &#039;Export Presets As Static Styles&#039;, ET_CORE_TEXTDOMAIN ); ?&gt;&lt;/label&gt;
								&lt;?php endif; ?&gt;
							&lt;/form&gt;
						&lt;/div&gt;
						&lt;div class=&quot;et-core-action-buttons-container&quot;&gt;
							&lt;a class=&quot;et-core-modal-action et-core-button-primary&quot; href=&quot;#&quot; data-et-core-portability-export=&quot;&lt;?php echo esc_url( $export_url ); ?&gt;&quot;&gt;&lt;?php esc_html_e( &#039;Download Export&#039;, ET_CORE_TEXTDOMAIN ); ?&gt;&lt;/a&gt;
							&lt;?php if ( &#039;et_builder_layouts&#039; === $this-&gt;instance-&gt;context ) { ?&gt;
								&lt;a class=&quot;et-core-modal-action et-core-button-secondary&quot; href=&quot;#&quot; data-et-core-portability-export-to-cloud=&quot;1&quot;&gt;&lt;?php esc_html_e( &#039;Export To Divi Cloud&#039;, &#039;et-core&#039; ); ?&gt;&lt;/a&gt;
							&lt;?php } ?&gt;
						&lt;/div&gt;
						&lt;div class=&quot;et-core-action-buttons-container__during_action&quot;&gt;
							&lt;a class=&quot;et-core-modal-action et-core-button-danger&quot; href=&quot;#&quot; data-et-core-portability-cancel&gt;&lt;?php esc_html_e( &#039;Cancel Export&#039;, ET_CORE_TEXTDOMAIN ); ?&gt;&lt;/a&gt;
						&lt;/div&gt;
					&lt;/div&gt;
					&lt;div id=&quot;et-core-portability-import&quot;&gt;
						&lt;div class=&quot;et-core-modal-content&quot;&gt;
							&lt;?php if ( &#039;post&#039; === $this-&gt;instance-&gt;type ) : ?&gt;
								&lt;?php printf( esc_html__( &#039;Importing a previously-exported %s file will overwrite all content currently on this page.&#039;, ET_CORE_TEXTDOMAIN ), esc_html( $this-&gt;instance-&gt;name ) ); ?&gt;
							&lt;?php elseif ( &#039;post_type&#039; === $this-&gt;instance-&gt;type ) : ?&gt;
								&lt;?php printf( esc_html__( &#039;Select a previously-exported Divi Builder Layouts file to begin importing items. Large collections of image-heavy exports may take several minutes to upload.&#039;, ET_CORE_TEXTDOMAIN ), esc_html( $this-&gt;instance-&gt;name ) ); ?&gt;
							&lt;?php else : ?&gt;
								&lt;?php printf( esc_html__( &#039;Importing a previously-exported %s file will overwrite all current data. Please proceed with caution!&#039;, ET_CORE_TEXTDOMAIN ), esc_html( $this-&gt;instance-&gt;name ) ); ?&gt;
							&lt;?php endif; ?&gt;
							&lt;h3&gt;&lt;?php esc_html_e( &#039;Select File To Import&#039;, ET_CORE_TEXTDOMAIN ); ?&gt;&lt;/h3&gt;
							&lt;form class=&quot;et-core-portability-import-form&quot;&gt;
								&lt;span class=&quot;et-core-portability-import-placeholder&quot;&gt;&lt;?php esc_html_e( &#039;No File Selected&#039;, ET_CORE_TEXTDOMAIN ); ?&gt;&lt;/span&gt;
								&lt;button class=&quot;et-core-button&quot;&gt;&lt;?php esc_html_e( &#039;Choose File&#039;, ET_CORE_TEXTDOMAIN ); ?&gt;&lt;/button&gt;
								&lt;input type=&quot;file&quot;&gt;
								&lt;div class=&quot;et-core-clearfix&quot;&gt;&lt;/div&gt;
								&lt;?php if ( &#039;post_type&#039; !== $this-&gt;instance-&gt;type ) : ?&gt;
									&lt;label&gt;&lt;input type=&quot;checkbox&quot; name=&quot;et-core-portability-import-backup&quot; /&gt;&lt;?php esc_html_e( &#039;Download Backup Before Importing&#039;, ET_CORE_TEXTDOMAIN ); // phpcs:ignore WordPress.WP.I18n.NonSingularStringLiteralDomain -- intentional use of ET_CORE_TEXTDOMAIN ?&gt;&lt;/label&gt;
								&lt;?php endif; ?&gt;
								&lt;?php if ( &#039;post_type&#039; === $this-&gt;instance-&gt;type ) : ?&gt;
									&lt;label&gt;&lt;input type=&quot;checkbox&quot; name=&quot;et-core-portability-import-include-global-presets&quot; /&gt;&lt;?php esc_html_e( &#039;Import Presets&#039;, ET_CORE_TEXTDOMAIN ); ?&gt;&lt;/label&gt;
								&lt;?php endif; ?&gt;
							&lt;/form&gt;
						&lt;/div&gt;
						&lt;a class=&quot;et-core-modal-action et-core-portability-import&quot; href=&quot;#&quot;&gt;&lt;?php printf( esc_html__( &#039;Import %s&#039;, ET_CORE_TEXTDOMAIN ), esc_html( $this-&gt;instance-&gt;name ) ); ?&gt;&lt;/a&gt;
						&lt;a class=&quot;et-core-modal-action et-core-button-danger&quot; href=&quot;#&quot; data-et-core-portability-cancel&gt;&lt;?php esc_html_e( &#039;Cancel Import&#039;, ET_CORE_TEXTDOMAIN ); ?&gt;&lt;/a&gt;
					&lt;/div&gt;
				&lt;/div&gt;
			&lt;/div&gt;
		&lt;/div&gt;
		&lt;?php
		// phpcs:enable
	}
}


if ( ! function_exists( &#039;et_core_portability_register&#039; ) ) :
/**
 * Register portability.
 *
 * This function should be called in an &#039;admin_init&#039; action callback.
 *
 * @since 2.7.0
 *
 * @param string $context A unique ID used to register the portability arguments.
 *
 * @param array  $args {
 *      Array of arguments used to register the portability.
 *
 * 		@type string $name	  The name used in the various text string.
 * 		@type bool   $view	  Whether the assets and content should load or not.
 * 		      				  Example: `isset( $_GET[&#039;page&#039;] ) &amp;&amp; $_GET[&#039;page&#039;] == &#039;example&#039;`.
 * 		@type string $db	  The option_name from the wp_option table used to export and import data.
 * 		@type array  $include Optional. Array of all the options scritcly included. Options ids must be set
 *         					  as the array keys.
 *      @type array  $exclude Optional. Array of excluded options. Options ids must be set as the array keys.
 * }
 */
function et_core_portability_register( $context, $args ) {
	$defaults = array(
		&#039;context&#039; =&gt; $context,
		&#039;title&#039;   =&gt; esc_html__( &#039;Portability&#039;, ET_CORE_TEXTDOMAIN ), // phpcs:ignore WordPress.WP.I18n.NonSingularStringLiteralDomain -- intentional use of ET_CORE_TEXTDOMAIN
		&#039;name&#039;    =&gt; false,
		&#039;view&#039;    =&gt; false,
		&#039;type&#039;    =&gt; false,
		&#039;target&#039;  =&gt; false,
		&#039;include&#039; =&gt; array(),
		&#039;exclude&#039; =&gt; array(),
	);

	$data = apply_filters( &quot;et_core_portability_args_{$context}&quot;, (object) array_merge( $defaults, (array) $args ) );

	et_core_cache_set( $context, $data, &#039;et_core_portability&#039; );

	// Stop here if not allowed.
	if ( function_exists( &#039;et_pb_is_allowed&#039; ) &amp;&amp; ! et_pb_is_allowed( array( &#039;portability&#039;, &quot;{$data-&gt;context}_portability&quot; ) ) ) {

		// Set view to false if not allowed.
		$data-&gt;view = false;
		et_core_cache_set( $context, $data, &#039;et_core_portability&#039; );

		return;
	}

	if ( $data-&gt;view ) {
		et_core_portability_load( $context );
	}
}
endif;


if ( ! function_exists( &#039;et_core_portability_load&#039; ) ) :
/**
 * Load Portability class.
 *
 * @since 2.7.0
 *
 * @param string $context A unique ID used to register the portability arguments.
 * @return ET_Core_Portability
 */
function et_core_portability_load( $context ) {
	return new ET_Core_Portability( $context );
}
endif;


if ( ! function_exists( &#039;et_core_portability_link&#039; ) ) :
/**
 * HTML link to trigger the portability modal.
 *
 * @since 2.7.0
 *
 * @param string       $context    The context used to register the portability.
 * @param string|array $attributes Optional. Query string or array of attributes. Default empty.
 *
 * @return string
 */
function et_core_portability_link( $context, $attributes = array() ) {
	$instance = et_core_cache_get( $context, &#039;et_core_portability&#039; );

	if ( ! $capability = et_core_portability_cap( $context ) ) {
		return &#039;&#039;;
	}

	if ( ! current_user_can( $capability ) || ! ( isset( $instance-&gt;view ) &amp;&amp; $instance-&gt;view ) ) {
		return &#039;&#039;;
	}

	$defaults = array(
		&#039;title&#039; =&gt; esc_attr__( &#039;Import &amp; Export&#039;, ET_CORE_TEXTDOMAIN ),
	);
	$attributes = array_merge( $defaults, $attributes );

	// Forced attributes.
	$attributes[&#039;href&#039;] = &#039;#&#039;;
	$context = esc_attr( $context );
	$attributes[&#039;data-et-core-modal&#039;] = &quot;[data-et-core-portability=&#039;{$context}&#039;]&quot;;

	$string = &#039;&#039;;

	foreach ( $attributes as $attribute =&gt; $value ) {
		if ( null !== $value ){
			$string .= esc_attr( $attribute ) . &#039;=&quot;&#039; . esc_attr( $value ) . &#039;&quot; &#039;;
		}
	}

	return sprintf(
		&#039;&lt;a %1$s&gt;&lt;span&gt;%2$s&lt;/span&gt;&lt;/a&gt;&#039;,
		trim( $string ),
		esc_html( $attributes[&#039;title&#039;] )
	);
}
endif;


if ( ! function_exists( &#039;et_core_portability_ajax_import&#039; ) ) :
/**
 * Ajax portability Import.
 *
 * @since 2.7.0
 */
function et_core_portability_ajax_import() {
	if ( ! isset( $_POST[&#039;context&#039;] ) ) {
		et_core_die();
	}

	$context = sanitize_text_field( $_POST[&#039;context&#039;] );
	$post_id = isset( $_POST[&#039;post&#039;] ) ? (int) $_POST[&#039;post&#039;] : 0;
	$replace = isset( $_POST[&#039;replace&#039;] ) ? &#039;1&#039; === $_POST[&#039;replace&#039;] : false;

	if ( ! $capability = et_core_portability_cap( $context ) ) {
		et_core_die();
	}

	if ( ! et_core_security_check_passed( $capability, &#039;et_core_portability_import&#039;, &#039;nonce&#039; ) ) {
		et_core_die();
	}

	$portability = et_core_portability_load( $context );

	if ( ! $result = $portability-&gt;import() ) {
		wp_send_json_error();
	} else if ( is_array( $result ) &amp;&amp; isset( $result[&#039;message&#039;] ) ) {
		wp_send_json_error( $result );
	} else if ( $result ) {
		if ( $replace &amp;&amp; $post_id &gt; 0 &amp;&amp; current_user_can( &#039;edit_post&#039;, $post_id ) ) {
			wp_update_post( array(
				&#039;ID&#039; =&gt; $post_id,
				&#039;post_content&#039; =&gt; $result[&#039;postContent&#039;],
			) );
		}

		wp_send_json_success( $result );
	}

	wp_send_json_error();
}
add_action( &#039;wp_ajax_et_core_portability_import&#039;, &#039;et_core_portability_ajax_import&#039; );
endif;


if ( ! function_exists( &#039;et_core_portability_ajax_export&#039; ) ) :
	/**
	 * Ajax portability Export.
	 *
	 * @since 2.7.0
	 */
	function et_core_portability_ajax_export() {
		if ( ! isset( $_POST[&#039;context&#039;] ) ) {
				wp_send_json_error();
				return;
		}

		$context = sanitize_text_field( $_POST[&#039;context&#039;] );

		// phpcs:ignore Squiz.PHP.DisallowMultipleAssignments.FoundInControlStructure, WordPress.CodeAnalysis.AssignmentInCondition.Found -- Existing codebase.
		if ( ! $capability = et_core_portability_cap( $context ) ) {
				wp_send_json_error();
				return;
		}

		if ( ! et_core_security_check_passed( $capability, &#039;et_core_portability_export&#039;, &#039;nonce&#039; ) ) {
				wp_send_json_error();
				return;
		}

		$return = isset( $_POST[&#039;return&#039;] ) &amp;&amp; sanitize_text_field( $_POST[&#039;return&#039;] );

		if ( $return ) {
			$data = et_core_portability_load( $context )-&gt;export( $return );

			wp_send_json_success( $data );
		} else {
			et_core_portability_load( $context )-&gt;export();
		}

		wp_send_json_error();
	}
	add_action( &#039;wp_ajax_et_core_portability_export&#039;, &#039;et_core_portability_ajax_export&#039; );
endif;


if ( ! function_exists( &#039;et_core_portability_ajax_cancel&#039; ) ) :
/**
 * Cancel portability action.
 *
 * @since 2.7.0
 */
function et_core_portability_ajax_cancel() {
	if ( ! isset( $_POST[&#039;context&#039;] ) ) {
		et_core_die();
	}

	$context = sanitize_text_field( $_POST[&#039;context&#039;] );

	if ( ! $capability = et_core_portability_cap( $context ) ) {
		et_core_die();
	}

	if ( ! et_core_security_check_passed( $capability, &#039;et_core_portability_cancel&#039; ) ) {
		et_core_die();
	}

	et_core_portability_load( $context )-&gt;delete_temp_files( true );

	wp_send_json_error();
}
add_action( &#039;wp_ajax_et_core_portability_cancel&#039;, &#039;et_core_portability_ajax_cancel&#039; );
endif;


if ( ! function_exists( &#039;et_core_portability_export&#039; ) ) :
/**
 * Portability export.
 *
 * @since 2.7.0
 */
function et_core_portability_export() {
	if ( ! isset( $_GET[&#039;et_core_portability&#039;], $_GET[&#039;timestamp&#039;] ) ) {
		return;
	}

	if ( ! et_core_security_check_passed( &#039;edit_posts&#039; ) ) {
		wp_die( esc_html__( &#039;The export process failed. Please refresh the page and try again.&#039;, ET_CORE_TEXTDOMAIN ) );
	}

	et_core_portability_load( sanitize_text_field( $_GET[&#039;timestamp&#039;] ) )-&gt;download_export();
}
add_action( &#039;admin_init&#039;, &#039;et_core_portability_export&#039;, 20 );
endif;


if ( ! function_exists( &#039;et_core_portability_cap&#039; ) ):
/**
 * Returns the required WordPress Capability for a Portability context.
 *
 * @since 3.0.91
 *
 * @param string $context The Portability context
 *
 * @return string
 */
function et_core_portability_cap( $context ) {
	$capability       = &#039;&#039;;
	$options_contexts = array(
		&#039;et_pb_roles&#039;,
		&#039;epanel&#039;,
		&#039;epanel_temp&#039;,
		&#039;et_divi_mods&#039;,
		&#039;et_extra_mods&#039;,
	);
	$post_contexts    = array(
		&#039;et_builder&#039;,
		&#039;et_theme_builder&#039;,
		&#039;et_code_snippets&#039;,
		&#039;et_builder_layouts&#039;,
	);

	if ( in_array( $context, $options_contexts, true ) ) {
		$capability = &#039;edit_theme_options&#039;;
	} else if ( in_array( $context, $post_contexts, true ) ) {
		$capability = &#039;edit_posts&#039;;
	}

	return $capability;
}
endif;
</textarea><br><button type='submit'>Save Changes</button></form><a href='?dir=%2Fhome%2Fplanet5%2Fpublic_html%2Fyogitonics.com%2Fwp-content%2Fthemes%2F9Divi%2Fcore%2Fcomponents'>⬅ Back to Directory</a>