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

use Elementor\Core\Utils\ImportExport\Parsers\WXR_Parser;
use WP_Error;

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

/**
 * Originally made by WordPress part of WordPress/Importer.
 * https://plugins.trac.wordpress.org/browser/wordpress-importer/trunk/class-wp-import.php
 *
 * What was done:
 * Reformat of the code.
 * Changed text domain.
 * Changed methods visibility.
 * Changed method from `get_authors_from_import` to `set_authors_from_import`.
 * Changed method from `get_author_mapping` to `set_author_mapping`.
 * Removed use of &#039;$_POST&#039; the input &#039;options&#039; will be passed via constructor args.
 * Removed echos, UI and print methods, all echos replaced with `$this-&gt;output` append.
 * Removed `die` ( exit(s) ).
 */

if ( ! class_exists( &#039;WP_Importer&#039; ) ) {
	$class_wp_importer = ABSPATH . &#039;wp-admin/includes/class-wp-importer.php&#039;;

	if ( file_exists( $class_wp_importer ) ) {
		require $class_wp_importer;
	}
}

if ( ! function_exists( &#039;wp_import_cleanup&#039; ) ) {
	require_once ABSPATH . &#039;wp-admin/includes/import.php&#039;;
}

class WP_Import extends \WP_Importer {
	const DEFAULT_BUMP_REQUEST_TIMEOUT = 60;
	const DEFAULT_ALLOW_CREATE_USERS = true;
	const DEFAULT_IMPORT_ATTACHMENT_SIZE_LIMIT = 0; // 0 = unlimited.

	/**
	 * @var string
	 */
	private $requested_file_path;

	/**
	 * @var array
	 */
	private $args;

	/**
	 * @var array
	 */
	private $output = [
		&#039;status&#039; =&gt; &#039;failed&#039;,
		&#039;errors&#039; =&gt; [],
	];

	/**
	 * WXR attachment ID
	 *
	 * @var string
	 */
	private $id;

	/**
	 * Information to import from WXR file.
	 */
	// phpcs:ignore Squiz.Commenting.VariableComment.MissingVar
	private $version;
	private $authors = [];
	private $posts = [];
	private $terms = [];
	private $base_url = &#039;&#039;;
	private $page_on_front;
	private $base_blog_url = &#039;&#039;;

	/**
	 * Mappings from old information to new.
	 */
	// phpcs:ignore Squiz.Commenting.VariableComment.MissingVar
	private $processed_taxonomies;
	private $processed_terms = [];
	private $processed_posts = [];
	private $processed_authors = [];
	private $author_mapping = [];
	private $processed_menu_items = [];
	private $post_orphans = [];
	private $menu_item_orphans = [];
	private $mapped_terms_slug = [];

	private $fetch_attachments = false;
	private $url_remap = [];
	private $featured_images = [];

	/**
	 * @var array[] [meta_key =&gt; meta_value] Meta value that should be set for every imported post.
	 */
	private $posts_meta = [];

	/**
	 * @var array[] [meta_key =&gt; meta_value] Meta value that should be set for every imported term.
	 */
	private $terms_meta = [];

	/**
	 * Parses filename from a Content-Disposition header value.
	 *
	 * As per RFC6266:
	 *
	 *     content-disposition = &quot;Content-Disposition&quot; &quot;:&quot;
	 *                            disposition-type *( &quot;;&quot; disposition-parm )
	 *
	 *     disposition-type    = &quot;inline&quot; | &quot;attachment&quot; | disp-ext-type
	 *                         ; case-insensitive
	 *     disp-ext-type       = token
	 *
	 *     disposition-parm    = filename-parm | disp-ext-parm
	 *
	 *     filename-parm       = &quot;filename&quot; &quot;=&quot; value
	 *                         | &quot;filename*&quot; &quot;=&quot; ext-value
	 *
	 *     disp-ext-parm       = token &quot;=&quot; value
	 *                         | ext-token &quot;=&quot; ext-value
	 *     ext-token           = &lt;the characters in token, followed by &quot;*&quot;&gt;
	 *
	 * @param string[] $disposition_header List of Content-Disposition header values.
	 *
	 * @return string|null Filename if available, or null if not found.
	 * @link  http://tools.ietf.org/html/rfc2388
	 * @link  http://tools.ietf.org/html/rfc6266
	 *
	 * @see WP_REST_Attachments_Controller::get_filename_from_disposition()
	 */
	protected static function get_filename_from_disposition( $disposition_header ) {
		// Get the filename.
		$filename = null;

		foreach ( $disposition_header as $value ) {
			$value = trim( $value );

			if ( strpos( $value, &#039;;&#039; ) === false ) {
				continue;
			}

			list( $type, $attr_parts ) = explode( &#039;;&#039;, $value, 2 );

			$attr_parts = explode( &#039;;&#039;, $attr_parts );
			$attributes = [];

			foreach ( $attr_parts as $part ) {
				if ( strpos( $part, &#039;=&#039; ) === false ) {
					continue;
				}

				list( $key, $value ) = explode( &#039;=&#039;, $part, 2 );

				$attributes[ trim( $key ) ] = trim( $value );
			}

			if ( empty( $attributes[&#039;filename&#039;] ) ) {
				continue;
			}

			$filename = trim( $attributes[&#039;filename&#039;] );

			// Unquote quoted filename, but after trimming.
			if ( substr( $filename, 0, 1 ) === &#039;&quot;&#039; &amp;&amp; substr( $filename, -1, 1 ) === &#039;&quot;&#039; ) {
				$filename = substr( $filename, 1, -1 );
			}
		}

		return $filename;
	}

	/**
	 * Retrieves file extension by mime type.
	 *
	 * @param string $mime_type Mime type to search extension for.
	 *
	 * @return string|null File extension if available, or null if not found.
	 */
	protected static function get_file_extension_by_mime_type( $mime_type ) {
		static $map = null;

		if ( is_array( $map ) ) {
			return isset( $map[ $mime_type ] ) ? $map[ $mime_type ] : null;
		}

		$mime_types = wp_get_mime_types();
		$map = array_flip( $mime_types );

		// Some types have multiple extensions, use only the first one.
		foreach ( $map as $type =&gt; $extensions ) {
			$map[ $type ] = strtok( $extensions, &#039;|&#039; );
		}

		return isset( $map[ $mime_type ] ) ? $map[ $mime_type ] : null;
	}

	/**
	 * The main controller for the actual import stage.
	 *
	 * @param string $file Path to the WXR file for importing
	 */
	private function import( $file ) {
		add_filter( &#039;import_post_meta_key&#039;, function ( $key ) {
			return $this-&gt;is_valid_meta_key( $key );
		} );
		add_filter( &#039;http_request_timeout&#039;, function () {
			return self::DEFAULT_BUMP_REQUEST_TIMEOUT;
		} );

		if ( ! $this-&gt;import_start( $file ) ) {
			return;
		}

		$this-&gt;set_author_mapping();

		wp_suspend_cache_invalidation( true );
		$imported_summary = [
			&#039;terms&#039; =&gt; $this-&gt;process_terms(),
			&#039;posts&#039; =&gt; $this-&gt;process_posts(),
		];
		wp_suspend_cache_invalidation( false );

		// Update incorrect/missing information in the DB.
		$this-&gt;backfill_parents();
		$this-&gt;backfill_attachment_urls();
		$this-&gt;remap_featured_images();

		$this-&gt;import_end();

		$is_some_succeed = false;
		foreach ( $imported_summary as $item ) {
			if ( $item &gt; 0 ) {
				$is_some_succeed = true;
				break;
			}
		}

		if ( $is_some_succeed ) {
			$this-&gt;output[&#039;status&#039;] = &#039;success&#039;;
			$this-&gt;output[&#039;summary&#039;] = $imported_summary;
		}
	}

	/**
	 * Parses the WXR file and prepares us for the task of processing parsed data.
	 *
	 * @param string $file Path to the WXR file for importing
	 */
	private function import_start( $file ) {
		if ( ! is_file( $file ) ) {
			$this-&gt;output[&#039;errors&#039;] = [ esc_html__( &#039;The file does not exist, please try again.&#039;, &#039;elementor&#039; ) ];

			return false;
		}

		$import_data = $this-&gt;parse( $file );

		if ( is_wp_error( $import_data ) ) {
			$this-&gt;output[&#039;errors&#039;] = [ $import_data-&gt;get_error_message() ];

			return false;
		}

		$this-&gt;version = $import_data[&#039;version&#039;];
		$this-&gt;set_authors_from_import( $import_data );
		$this-&gt;posts = $this-&gt;filter_import_posts( $import_data[&#039;posts&#039;] );
		$this-&gt;terms = $import_data[&#039;terms&#039;];
		$this-&gt;base_url = esc_url( $import_data[&#039;base_url&#039;] );
		$this-&gt;base_blog_url = esc_url( $import_data[&#039;base_blog_url&#039;] );
		$this-&gt;page_on_front = $import_data[&#039;page_on_front&#039;];

		wp_defer_term_counting( true );
		wp_defer_comment_counting( true );

		do_action( &#039;import_start&#039; );

		return true;
	}

	private function filter_import_posts( array $posts ): array {
		if ( isset( $this-&gt;args[&#039;include&#039;] ) ) {
			$filtered_posts = [];

			foreach ( $posts as $post ) {
				if ( in_array( $post[&#039;post_id&#039;], $this-&gt;args[&#039;include&#039;] ) ) {
					$filtered_posts[] = $post;
				}
			}

			return $filtered_posts;
		}

		return $posts;
	}

	/**
	 * Performs post-import cleanup of files and the cache
	 */
	private function import_end() {
		wp_import_cleanup( $this-&gt;id );

		wp_cache_flush();

		foreach ( get_taxonomies() as $tax ) {
			delete_option( &quot;{$tax}_children&quot; );
			_get_term_hierarchy( $tax );
		}

		wp_defer_term_counting( false );
		wp_defer_comment_counting( false );

		do_action( &#039;import_end&#039; );
	}

	/**
	 * Retrieve authors from parsed WXR data and set it to `$this-&gt;&gt;authors`.
	 *
	 * Uses the provided author information from WXR 1.1 files
	 * or extracts info from each post for WXR 1.0 files
	 *
	 * @param array $import_data Data returned by a WXR parser
	 */
	private function set_authors_from_import( $import_data ) {
		if ( ! empty( $import_data[&#039;authors&#039;] ) ) {
			$this-&gt;authors = $import_data[&#039;authors&#039;];
			// No author information, grab it from the posts.
		} else {
			foreach ( $import_data[&#039;posts&#039;] as $post ) {
				$login = sanitize_user( $post[&#039;post_author&#039;], true );

				if ( empty( $login ) ) {
					$this-&gt;output[&#039;errors&#039;][] = sprintf(
						/* translators: %s: Post author. */
						esc_html__( &#039;Failed to import author %s. Their posts will be attributed to the current user.&#039;, &#039;elementor&#039; ),
						$post[&#039;post_author&#039;]
					);
					continue;
				}

				if ( ! isset( $this-&gt;authors[ $login ] ) ) {
					$this-&gt;authors[ $login ] = [
						&#039;author_login&#039; =&gt; $login,
						&#039;author_display_name&#039; =&gt; $post[&#039;post_author&#039;],
					];
				}
			}
		}
	}

	/**
	 * Map old author logins to local user IDs based on decisions made
	 * in import options form. Can map to an existing user, create a new user
	 * or falls back to the current user in case of error with either of the previous
	 */
	private function set_author_mapping() {
		if ( ! isset( $this-&gt;args[&#039;imported_authors&#039;] ) ) {
			return;
		}

		$create_users = apply_filters( &#039;import_allow_create_users&#039;, self::DEFAULT_ALLOW_CREATE_USERS );

		foreach ( (array) $this-&gt;args[&#039;imported_authors&#039;] as $i =&gt; $old_login ) {
			// Multisite adds strtolower to sanitize_user. Need to sanitize here to stop breakage in process_posts.
			$sanitized_old_login = sanitize_user( $old_login, true );
			$old_id = isset( $this-&gt;authors[ $old_login ][&#039;author_id&#039;] ) ? (int) $this-&gt;authors[ $old_login ][&#039;author_id&#039;] : false;

			if ( ! empty( $this-&gt;args[&#039;user_map&#039;][ $i ] ) ) {
				$user = get_userdata( (int) $this-&gt;args[&#039;user_map&#039;][ $i ] );
				if ( isset( $user-&gt;ID ) ) {
					if ( $old_id ) {
						$this-&gt;processed_authors[ $old_id ] = $user-&gt;ID;
					}
					$this-&gt;author_mapping[ $sanitized_old_login ] = $user-&gt;ID;
				}
			} elseif ( $create_users ) {
				$user_id = 0;
				if ( ! empty( $this-&gt;args[&#039;user_new&#039;][ $i ] ) ) {
					$user_id = wp_create_user( $this-&gt;args[&#039;user_new&#039;][ $i ], wp_generate_password() );
				} elseif ( &#039;1.0&#039; !== $this-&gt;version ) {
					$user_data = [
						&#039;user_login&#039; =&gt; $old_login,
						&#039;user_pass&#039; =&gt; wp_generate_password(),
						&#039;user_email&#039; =&gt; isset( $this-&gt;authors[ $old_login ][&#039;author_email&#039;] ) ? $this-&gt;authors[ $old_login ][&#039;author_email&#039;] : &#039;&#039;,
						&#039;display_name&#039; =&gt; $this-&gt;authors[ $old_login ][&#039;author_display_name&#039;],
						&#039;first_name&#039; =&gt; isset( $this-&gt;authors[ $old_login ][&#039;author_first_name&#039;] ) ? $this-&gt;authors[ $old_login ][&#039;author_first_name&#039;] : &#039;&#039;,
						&#039;last_name&#039; =&gt; isset( $this-&gt;authors[ $old_login ][&#039;author_last_name&#039;] ) ? $this-&gt;authors[ $old_login ][&#039;author_last_name&#039;] : &#039;&#039;,
					];
					$user_id = wp_insert_user( $user_data );
				}

				if ( ! is_wp_error( $user_id ) ) {
					if ( $old_id ) {
						$this-&gt;processed_authors[ $old_id ] = $user_id;
					}
					$this-&gt;author_mapping[ $sanitized_old_login ] = $user_id;
				} else {
					$error = sprintf(
						/* translators: %s: Author display name. */
						esc_html__( &#039;Failed to create new user for %s. Their posts will be attributed to the current user.&#039;, &#039;elementor&#039; ),
						$this-&gt;authors[ $old_login ][&#039;author_display_name&#039;]
					);

					if ( defined( &#039;IMPORT_DEBUG&#039; ) &amp;&amp; IMPORT_DEBUG ) {
						$error .= PHP_EOL . $user_id-&gt;get_error_message();
					}

					$this-&gt;output[&#039;errors&#039;][] = $error;
				}
			}

			// Failsafe: if the user_id was invalid, default to the current user.
			if ( ! isset( $this-&gt;author_mapping[ $sanitized_old_login ] ) ) {
				if ( $old_id ) {
					$this-&gt;processed_authors[ $old_id ] = (int) get_current_user_id();
				}
				$this-&gt;author_mapping[ $sanitized_old_login ] = (int) get_current_user_id();
			}
		}
	}

	/**
	 * Create new terms based on import information
	 *
	 * Doesn&#039;t create a term its slug already exists
	 *
	 * @return array|array[] the ids of succeed/failed imported terms.
	 */
	private function process_terms() {
		$result = [
			&#039;succeed&#039; =&gt; [],
			&#039;failed&#039; =&gt; [],
		];

		$this-&gt;terms = apply_filters( &#039;wp_import_terms&#039;, $this-&gt;terms );

		if ( empty( $this-&gt;terms ) ) {
			return $result;
		}

		foreach ( $this-&gt;terms as $term ) {

			// if the term already exists in the correct taxonomy leave it alone
			$term_id = term_exists( $term[&#039;slug&#039;], $term[&#039;term_taxonomy&#039;] );
			if ( $term_id ) {
				if ( is_array( $term_id ) ) {
					$term_id = $term_id[&#039;term_id&#039;];
				}

				if ( isset( $term[&#039;term_id&#039;] ) ) {
					if ( &#039;nav_menu&#039; === $term[&#039;term_taxonomy&#039;] ) {
						// BC - support old kits that the menu terms are part of the &#039;nav_menu_item&#039; post type
						// and not part of the taxonomies.
						if ( ! empty( $this-&gt;processed_taxonomies[ $term[&#039;term_taxonomy&#039;] ] ) ) {
							foreach ( $this-&gt;processed_taxonomies[ $term[&#039;term_taxonomy&#039;] ] as $processed_term ) {
								$old_slug   = $processed_term[&#039;old_slug&#039;];
								$new_slug = $processed_term[&#039;new_slug&#039;];

								$this-&gt;mapped_terms_slug[ $old_slug ] = $new_slug;
								$result[&#039;succeed&#039;][ $old_slug ] = $new_slug;
							}
							continue;
						} else {
							$term = $this-&gt;handle_duplicated_nav_menu_term( $term );
						}
					} else {
						$this-&gt;processed_terms[ (int) $term[&#039;term_id&#039;] ] = (int) $term_id;
						$result[&#039;succeed&#039;][ (int) $term[&#039;term_id&#039;] ] = (int) $term_id;
						continue;
					}
				}
			}

			if ( empty( $term[&#039;term_parent&#039;] ) ) {
				$parent = 0;
			} else {
				$parent = term_exists( $term[&#039;term_parent&#039;], $term[&#039;term_taxonomy&#039;] );
				if ( is_array( $parent ) ) {
					$parent = $parent[&#039;term_id&#039;];
				}
			}

			$description = isset( $term[&#039;term_description&#039;] ) ? $term[&#039;term_description&#039;] : &#039;&#039;;
			$args = [
				&#039;slug&#039; =&gt; $term[&#039;slug&#039;],
				&#039;description&#039; =&gt; wp_slash( $description ),
				&#039;parent&#039; =&gt; (int) $parent,
			];

			$id = wp_insert_term( wp_slash( $term[&#039;term_name&#039;] ), $term[&#039;term_taxonomy&#039;], $args );
			if ( ! is_wp_error( $id ) ) {
				if ( isset( $term[&#039;term_id&#039;] ) ) {
					$this-&gt;processed_terms[ (int) $term[&#039;term_id&#039;] ] = $id[&#039;term_id&#039;];
					$result[&#039;succeed&#039;][ (int) $term[&#039;term_id&#039;] ] = $id[&#039;term_id&#039;];

					$this-&gt;update_term_meta( $id[&#039;term_id&#039;] );
				}
			} else {
				/* translators: 1: Term taxonomy, 2: Term name. */
				$error = sprintf( esc_html__( &#039;Failed to import %1$s %2$s&#039;, &#039;elementor&#039; ), $term[&#039;term_taxonomy&#039;], $term[&#039;term_name&#039;] );

				if ( defined( &#039;IMPORT_DEBUG&#039; ) &amp;&amp; IMPORT_DEBUG ) {
					$error .= PHP_EOL . $id-&gt;get_error_message();
				}

				$result[&#039;failed&#039;][] = $id;
				$this-&gt;output[&#039;errors&#039;][] = $error;
				continue;
			}

			$this-&gt;process_termmeta( $term, $id[&#039;term_id&#039;] );
		}

		unset( $this-&gt;terms );

		return $result;
	}

	/**
	 * Add metadata to imported term.
	 *
	 * @param array $term    Term data from WXR import.
	 * @param int   $term_id ID of the newly created term.
	 */
	private function process_termmeta( $term, $term_id ) {
		if ( ! function_exists( &#039;add_term_meta&#039; ) ) {
			return;
		}

		if ( ! isset( $term[&#039;termmeta&#039;] ) ) {
			$term[&#039;termmeta&#039;] = [];
		}

		/**
		 * Filters the metadata attached to an imported term.
		 *
		 * @param array $termmeta Array of term meta.
		 * @param int   $term_id  ID of the newly created term.
		 * @param array $term     Term data from the WXR import.
		 */
		$term[&#039;termmeta&#039;] = apply_filters( &#039;wp_import_term_meta&#039;, $term[&#039;termmeta&#039;], $term_id, $term );

		if ( empty( $term[&#039;termmeta&#039;] ) ) {
			return;
		}

		foreach ( $term[&#039;termmeta&#039;] as $meta ) {
			/**
			 * Filters the meta key for an imported piece of term meta.
			 *
			 * @param string $meta_key Meta key.
			 * @param int    $term_id  ID of the newly created term.
			 * @param array  $term     Term data from the WXR import.
			 */
			$key = apply_filters( &#039;import_term_meta_key&#039;, $meta[&#039;key&#039;], $term_id, $term );
			if ( ! $key ) {
				continue;
			}

			// Export gets meta straight from the DB so could have a serialized string
			$value = maybe_unserialize( $meta[&#039;value&#039;] );

			add_term_meta( $term_id, wp_slash( $key ), wp_slash_strings_only( $value ) );

			/**
			 * Fires after term meta is imported.
			 *
			 * @param int    $term_id ID of the newly created term.
			 * @param string $key     Meta key.
			 * @param mixed  $value   Meta value.
			 */
			do_action( &#039;import_term_meta&#039;, $term_id, $key, $value );
		}
	}

	/**
	 * Create new posts based on import information
	 *
	 * Posts marked as having a parent which doesn&#039;t exist will become top level items.
	 * Doesn&#039;t create a new post if: the post type doesn&#039;t exist, the given post ID
	 * is already noted as imported or a post with the same title and date already exists.
	 * Note that new/updated terms, comments and meta are imported for the last of the above.
	 *
	 * @return array the ids of succeed/failed imported posts.
	 */
	private function process_posts() {
		$result = [
			&#039;succeed&#039; =&gt; [],
			&#039;failed&#039; =&gt; [],
		];

		$this-&gt;posts = apply_filters( &#039;wp_import_posts&#039;, $this-&gt;posts );

		foreach ( $this-&gt;posts as $post ) {
			$post = apply_filters( &#039;wp_import_post_data_raw&#039;, $post );

			if ( ! post_type_exists( $post[&#039;post_type&#039;] ) ) {
				/* translators: 1: Post title, 2: Post type. */
				$this-&gt;output[&#039;errors&#039;][] = sprintf( esc_html__( &#039;Failed to import %1$s: Invalid post type %2$s&#039;, &#039;elementor&#039; ), $post[&#039;post_title&#039;], $post[&#039;post_type&#039;] );
				do_action( &#039;wp_import_post_exists&#039;, $post );
				continue;
			}

			if ( isset( $this-&gt;processed_posts[ $post[&#039;post_id&#039;] ] ) &amp;&amp; ! empty( $post[&#039;post_id&#039;] ) ) {
				continue;
			}

			if ( &#039;auto-draft&#039; === $post[&#039;status&#039;] ) {
				continue;
			}

			if ( &#039;nav_menu_item&#039; === $post[&#039;post_type&#039;] ) {
				$result[&#039;succeed&#039;] += $this-&gt;process_menu_item( $post );

				continue;
			}

			$post_type_object = get_post_type_object( $post[&#039;post_type&#039;] );

			$post_parent = (int) $post[&#039;post_parent&#039;];
			if ( $post_parent ) {
				// if we already know the parent, map it to the new local ID.
				if ( isset( $this-&gt;processed_posts[ $post_parent ] ) ) {
					$post_parent = $this-&gt;processed_posts[ $post_parent ];
					// otherwise record the parent for later.
				} else {
					$this-&gt;post_orphans[ (int) $post[&#039;post_id&#039;] ] = $post_parent;
					$post_parent = 0;
				}
			}

			// Map the post author.
			$author = sanitize_user( $post[&#039;post_author&#039;], true );
			if ( isset( $this-&gt;author_mapping[ $author ] ) ) {
				$author = $this-&gt;author_mapping[ $author ];
			} else {
				$author = (int) get_current_user_id();
			}

			$postdata = [
				&#039;post_author&#039; =&gt; $author,
				&#039;post_content&#039; =&gt; $post[&#039;post_content&#039;],
				&#039;post_excerpt&#039; =&gt; $post[&#039;post_excerpt&#039;],
				&#039;post_title&#039; =&gt; $post[&#039;post_title&#039;],
				&#039;post_status&#039; =&gt; $post[&#039;status&#039;],
				&#039;post_name&#039; =&gt; $post[&#039;post_name&#039;],
				&#039;comment_status&#039; =&gt; $post[&#039;comment_status&#039;],
				&#039;ping_status&#039; =&gt; $post[&#039;ping_status&#039;],
				&#039;guid&#039; =&gt; $post[&#039;guid&#039;],
				&#039;post_parent&#039; =&gt; $post_parent,
				&#039;menu_order&#039; =&gt; $post[&#039;menu_order&#039;],
				&#039;post_type&#039; =&gt; $post[&#039;post_type&#039;],
				&#039;post_password&#039; =&gt; $post[&#039;post_password&#039;],
			];

			$original_post_id = $post[&#039;post_id&#039;];
			$postdata = apply_filters( &#039;wp_import_post_data_processed&#039;, $postdata, $post );

			$postdata = wp_slash( $postdata );

			if ( &#039;attachment&#039; === $postdata[&#039;post_type&#039;] ) {
				$remote_url = ! empty( $post[&#039;attachment_url&#039;] ) ? $post[&#039;attachment_url&#039;] : $post[&#039;guid&#039;];

				// try to use _wp_attached file for upload folder placement to ensure the same location as the export site
				// e.g. location is 2003/05/image.jpg but the attachment post_date is 2010/09, see media_handle_upload()
				$postdata[&#039;upload_date&#039;] = $post[&#039;post_date&#039;];
				if ( isset( $post[&#039;postmeta&#039;] ) ) {
					foreach ( $post[&#039;postmeta&#039;] as $meta ) {
						if ( &#039;_wp_attached_file&#039; === $meta[&#039;key&#039;] ) {
							if ( preg_match( &#039;%^[0-9]{4}/[0-9]{2}%&#039;, $meta[&#039;value&#039;], $matches ) ) {
								$postdata[&#039;upload_date&#039;] = $matches[0];
							}
							break;
						}
					}
				}

				$post_id = $this-&gt;process_attachment( $postdata, $remote_url );
				$comment_post_id = $post_id;
			} else {
				$post_id = wp_insert_post( $postdata, true );

				$this-&gt;update_post_meta( $post_id );

				$comment_post_id = $post_id;
				do_action( &#039;wp_import_insert_post&#039;, $post_id, $original_post_id, $postdata, $post );
			}

			if ( is_wp_error( $post_id ) ) {
				/* translators: 1: Post type singular label, 2: Post title. */
				$error = sprintf( __( &#039;Failed to import %1$s %2$s&#039;, &#039;elementor&#039; ), $post_type_object-&gt;labels-&gt;singular_name, $post[&#039;post_title&#039;] );

				if ( defined( &#039;IMPORT_DEBUG&#039; ) &amp;&amp; IMPORT_DEBUG ) {
					$error .= PHP_EOL . $post_id-&gt;get_error_message();
				}

				$result[&#039;failed&#039;][] = $original_post_id;

				$this-&gt;output[&#039;errors&#039;][] = $error;

				continue;
			}

			$result[&#039;succeed&#039;][ $original_post_id ] = $post_id;

			if ( 1 === $post[&#039;is_sticky&#039;] ) {
				stick_post( $post_id );
			}

			if ( $this-&gt;page_on_front === $original_post_id ) {
				update_option( &#039;page_on_front&#039;, $post_id );
			}

			// Map pre-import ID to local ID.
			$this-&gt;processed_posts[ (int) $post[&#039;post_id&#039;] ] = (int) $post_id;

			if ( ! isset( $post[&#039;terms&#039;] ) ) {
				$post[&#039;terms&#039;] = [];
			}

			$post[&#039;terms&#039;] = apply_filters( &#039;wp_import_post_terms&#039;, $post[&#039;terms&#039;], $post_id, $post );

			// add categories, tags and other terms
			if ( ! empty( $post[&#039;terms&#039;] ) ) {
				$terms_to_set = [];
				foreach ( $post[&#039;terms&#039;] as $term ) {
					// back compat with WXR 1.0 map &#039;tag&#039; to &#039;post_tag&#039;
					$taxonomy = ( &#039;tag&#039; === $term[&#039;domain&#039;] ) ? &#039;post_tag&#039; : $term[&#039;domain&#039;];
					$term_exists = term_exists( $term[&#039;slug&#039;], $taxonomy );
					$term_id = is_array( $term_exists ) ? $term_exists[&#039;term_id&#039;] : $term_exists;
					if ( ! $term_id ) {
						$t = wp_insert_term( $term[&#039;name&#039;], $taxonomy, [ &#039;slug&#039; =&gt; $term[&#039;slug&#039;] ] );
						if ( ! is_wp_error( $t ) ) {
							$term_id = $t[&#039;term_id&#039;];

							$this-&gt;update_term_meta( $term_id );

							do_action( &#039;wp_import_insert_term&#039;, $t, $term, $post_id, $post );
						} else {
							/* translators: 1: Taxonomy name, 2: Term name. */
							$error = sprintf( esc_html__( &#039;Failed to import %1$s %2$s&#039;, &#039;elementor&#039; ), $taxonomy, $term[&#039;name&#039;] );

							if ( defined( &#039;IMPORT_DEBUG&#039; ) &amp;&amp; IMPORT_DEBUG ) {
								$error .= PHP_EOL . $t-&gt;get_error_message();
							}

							$this-&gt;output[&#039;errors&#039;][] = $error;

							do_action( &#039;wp_import_insert_term_failed&#039;, $t, $term, $post_id, $post );
							continue;
						}
					}
					$terms_to_set[ $taxonomy ][] = (int) $term_id;
				}

				foreach ( $terms_to_set as $tax =&gt; $ids ) {
					$tt_ids = wp_set_post_terms( $post_id, $ids, $tax );
					do_action( &#039;wp_import_set_post_terms&#039;, $tt_ids, $ids, $tax, $post_id, $post );
				}
				unset( $post[&#039;terms&#039;], $terms_to_set );
			}

			if ( ! isset( $post[&#039;comments&#039;] ) ) {
				$post[&#039;comments&#039;] = [];
			}

			$post[&#039;comments&#039;] = apply_filters( &#039;wp_import_post_comments&#039;, $post[&#039;comments&#039;], $post_id, $post );

			// Add/update comments.
			if ( ! empty( $post[&#039;comments&#039;] ) ) {
				$num_comments = 0;
				$inserted_comments = [];
				foreach ( $post[&#039;comments&#039;] as $comment ) {
					$comment_id = $comment[&#039;comment_id&#039;];
					$newcomments[ $comment_id ][&#039;comment_post_ID&#039;] = $comment_post_id;
					$newcomments[ $comment_id ][&#039;comment_author&#039;] = $comment[&#039;comment_author&#039;];
					$newcomments[ $comment_id ][&#039;comment_author_email&#039;] = $comment[&#039;comment_author_email&#039;];
					$newcomments[ $comment_id ][&#039;comment_author_IP&#039;] = $comment[&#039;comment_author_IP&#039;];
					$newcomments[ $comment_id ][&#039;comment_author_url&#039;] = $comment[&#039;comment_author_url&#039;];
					$newcomments[ $comment_id ][&#039;comment_date&#039;] = $comment[&#039;comment_date&#039;];
					$newcomments[ $comment_id ][&#039;comment_date_gmt&#039;] = $comment[&#039;comment_date_gmt&#039;];
					$newcomments[ $comment_id ][&#039;comment_content&#039;] = $comment[&#039;comment_content&#039;];
					$newcomments[ $comment_id ][&#039;comment_approved&#039;] = $comment[&#039;comment_approved&#039;];
					$newcomments[ $comment_id ][&#039;comment_type&#039;] = $comment[&#039;comment_type&#039;];
					$newcomments[ $comment_id ][&#039;comment_parent&#039;] = $comment[&#039;comment_parent&#039;];
					$newcomments[ $comment_id ][&#039;commentmeta&#039;] = isset( $comment[&#039;commentmeta&#039;] ) ? $comment[&#039;commentmeta&#039;] : [];
					if ( isset( $this-&gt;processed_authors[ $comment[&#039;comment_user_id&#039;] ] ) ) {
						$newcomments[ $comment_id ][&#039;user_id&#039;] = $this-&gt;processed_authors[ $comment[&#039;comment_user_id&#039;] ];
					}
				}

				ksort( $newcomments );

				foreach ( $newcomments as $key =&gt; $comment ) {
					if ( isset( $inserted_comments[ $comment[&#039;comment_parent&#039;] ] ) ) {
						$comment[&#039;comment_parent&#039;] = $inserted_comments[ $comment[&#039;comment_parent&#039;] ];
					}

					$comment_data = wp_slash( $comment );
					unset( $comment_data[&#039;commentmeta&#039;] ); // Handled separately, wp_insert_comment() also expects `comment_meta`.
					$comment_data = wp_filter_comment( $comment_data );

					$inserted_comments[ $key ] = wp_insert_comment( $comment_data );

					do_action( &#039;wp_import_insert_comment&#039;, $inserted_comments[ $key ], $comment, $comment_post_id, $post );

					foreach ( $comment[&#039;commentmeta&#039;] as $meta ) {
						$value = maybe_unserialize( $meta[&#039;value&#039;] );

						add_comment_meta( $inserted_comments[ $key ], wp_slash( $meta[&#039;key&#039;] ), wp_slash_strings_only( $value ) );
					}

					$num_comments++;
				}
				unset( $newcomments, $inserted_comments, $post[&#039;comments&#039;] );
			}

			if ( ! isset( $post[&#039;postmeta&#039;] ) ) {
				$post[&#039;postmeta&#039;] = [];
			}

			$post[&#039;postmeta&#039;] = apply_filters( &#039;wp_import_post_meta&#039;, $post[&#039;postmeta&#039;], $post_id, $post );

			// Add/update post meta.
			if ( ! empty( $post[&#039;postmeta&#039;] ) ) {
				foreach ( $post[&#039;postmeta&#039;] as $meta ) {
					$key = apply_filters( &#039;import_post_meta_key&#039;, $meta[&#039;key&#039;], $post_id, $post );
					$value = false;

					if ( &#039;_edit_last&#039; === $key ) {
						if ( isset( $this-&gt;processed_authors[ (int) $meta[&#039;value&#039;] ] ) ) {
							$value = $this-&gt;processed_authors[ (int) $meta[&#039;value&#039;] ];
						} else {
							$key = false;
						}
					}

					if ( $key ) {
						// Export gets meta straight from the DB so could have a serialized string.
						if ( ! $value ) {
							$value = maybe_unserialize( $meta[&#039;value&#039;] );
						}

						add_post_meta( $post_id, wp_slash( $key ), wp_slash_strings_only( $value ) );

						do_action( &#039;import_post_meta&#039;, $post_id, $key, $value );

						// If the post has a featured image, take note of this in case of remap.
						if ( &#039;_thumbnail_id&#039; === $key ) {
							$this-&gt;featured_images[ $post_id ] = (int) $value;
						}
					}
				}
			}
		}

		unset( $this-&gt;posts );

		return $result;
	}

	/**
	 * Attempt to create a new menu item from import data
	 *
	 * Fails for draft, orphaned menu items and those without an associated nav_menu
	 * or an invalid nav_menu term. If the post type or term object which the menu item
	 * represents doesn&#039;t exist then the menu item will not be imported (waits until the
	 * end of the import to retry again before discarding).
	 *
	 * @param array $item Menu item details from WXR file
	 */
	private function process_menu_item( $item ) {
		$result = [];

		// Skip draft, orphaned menu items.
		if ( &#039;draft&#039; === $item[&#039;status&#039;] ) {
			return;
		}

		$menu_slug = false;
		if ( isset( $item[&#039;terms&#039;] ) ) {
			// Loop through terms, assume first nav_menu term is correct menu.
			foreach ( $item[&#039;terms&#039;] as $term ) {
				if ( &#039;nav_menu&#039; === $term[&#039;domain&#039;] ) {
					$menu_slug = $term[&#039;slug&#039;];
					break;
				}
			}
		}

		// No nav_menu term associated with this menu item.
		if ( ! $menu_slug ) {
			$this-&gt;output[&#039;errors&#039;][] = esc_html__( &#039;Menu item skipped due to missing menu slug&#039;, &#039;elementor&#039; );

			return $result;
		}

		// If menu was already exists, refer the items to the duplicated menu created.
		if ( array_key_exists( $menu_slug, $this-&gt;mapped_terms_slug ) ) {
			$menu_slug = $this-&gt;mapped_terms_slug[ $menu_slug ];
		}

		$menu_id = term_exists( $menu_slug, &#039;nav_menu&#039; );
		if ( ! $menu_id ) {
			/* translators: %s: Menu slug. */
			$this-&gt;output[&#039;errors&#039;][] = sprintf( esc_html__( &#039;Menu item skipped due to invalid menu slug: %s&#039;, &#039;elementor&#039; ), $menu_slug );

			return $result;
		} else {
			$menu_id = is_array( $menu_id ) ? $menu_id[&#039;term_id&#039;] : $menu_id;
		}

		$post_meta_key_value = [];
		foreach ( $item[&#039;postmeta&#039;] as $meta ) {
			$post_meta_key_value[ $meta[&#039;key&#039;] ] = $meta[&#039;value&#039;];
		}

		$_menu_item_type = $post_meta_key_value[&#039;_menu_item_type&#039;];
		$_menu_item_url = $post_meta_key_value[&#039;_menu_item_url&#039;];

		// Skip menu items &#039;taxonomy&#039; type, when the taxonomy is not exits.
		if ( &#039;taxonomy&#039; === $_menu_item_type &amp;&amp; ! taxonomy_exists( $post_meta_key_value[&#039;_menu_item_object&#039;] ) ) {
			return $result;
		}

		// Skip menu items &#039;post_type&#039; type, when the post type is not exits.
		if ( &#039;post_type&#039; === $_menu_item_type &amp;&amp; ! post_type_exists( $post_meta_key_value[&#039;_menu_item_object&#039;] ) ) {
			return $result;
		}

		$_menu_item_object_id = $post_meta_key_value[&#039;_menu_item_object_id&#039;];
		if ( &#039;taxonomy&#039; === $_menu_item_type &amp;&amp; isset( $this-&gt;processed_terms[ (int) $_menu_item_object_id ] ) ) {
			$_menu_item_object_id = $this-&gt;processed_terms[ (int) $_menu_item_object_id ];
		} elseif ( &#039;post_type&#039; === $_menu_item_type &amp;&amp; isset( $this-&gt;processed_posts[ (int) $_menu_item_object_id ] ) ) {
			$_menu_item_object_id = $this-&gt;processed_posts[ (int) $_menu_item_object_id ];
		} elseif ( &#039;custom&#039; === $_menu_item_type ) {
				$_menu_item_url = Url::migrate( $_menu_item_url, $this-&gt;base_blog_url );
		} else {
			return $result;
		}

		$_menu_item_menu_item_parent = $post_meta_key_value[&#039;_menu_item_menu_item_parent&#039;];
		if ( isset( $this-&gt;processed_menu_items[ (int) $_menu_item_menu_item_parent ] ) ) {
			$_menu_item_menu_item_parent = $this-&gt;processed_menu_items[ (int) $_menu_item_menu_item_parent ];
		} elseif ( $_menu_item_menu_item_parent ) {
			$this-&gt;menu_item_orphans[ (int) $item[&#039;post_id&#039;] ] = (int) $_menu_item_menu_item_parent;
			$_menu_item_menu_item_parent = 0;
		}

		// wp_update_nav_menu_item expects CSS classes as a space separated string
		$_menu_item_classes = maybe_unserialize( $post_meta_key_value[&#039;_menu_item_classes&#039;] );
		if ( is_array( $_menu_item_classes ) ) {
			$_menu_item_classes = implode( &#039; &#039;, $_menu_item_classes );
		}

		$args = [
			&#039;menu-item-object-id&#039; =&gt; $_menu_item_object_id,
			&#039;menu-item-object&#039; =&gt; $post_meta_key_value[&#039;_menu_item_object&#039;],
			&#039;menu-item-parent-id&#039; =&gt; $_menu_item_menu_item_parent,
			&#039;menu-item-position&#039; =&gt; (int) $item[&#039;menu_order&#039;],
			&#039;menu-item-type&#039; =&gt; $_menu_item_type,
			&#039;menu-item-title&#039; =&gt; $item[&#039;post_title&#039;],
			&#039;menu-item-url&#039; =&gt; $_menu_item_url,
			&#039;menu-item-description&#039; =&gt; $item[&#039;post_content&#039;],
			&#039;menu-item-attr-title&#039; =&gt; $item[&#039;post_excerpt&#039;],
			&#039;menu-item-target&#039; =&gt; $post_meta_key_value[&#039;_menu_item_target&#039;],
			&#039;menu-item-classes&#039; =&gt; $_menu_item_classes,
			&#039;menu-item-xfn&#039; =&gt; $post_meta_key_value[&#039;_menu_item_xfn&#039;],
			&#039;menu-item-status&#039; =&gt; $item[&#039;status&#039;],
		];

		$id = wp_update_nav_menu_item( $menu_id, 0, $args );
		if ( $id &amp;&amp; ! is_wp_error( $id ) ) {
			$this-&gt;processed_menu_items[ (int) $item[&#039;post_id&#039;] ] = (int) $id;
			$result[ $item[&#039;post_id&#039;] ] = $id;

			$this-&gt;update_post_meta( $id );
		}

		return $result;
	}

	/**
	 * If fetching attachments is enabled then attempt to create a new attachment
	 *
	 * @param array  $post Attachment post details from WXR
	 * @param string $url  URL to fetch attachment from
	 *
	 * @return int|WP_Error Post ID on success, WP_Error otherwise
	 */
	private function process_attachment( $post, $url ) {
		if ( ! $this-&gt;fetch_attachments ) {
			return new WP_Error( &#039;attachment_processing_error&#039;, esc_html__( &#039;Fetching attachments is not enabled&#039;, &#039;elementor&#039; ) );
		}

		// if the URL is absolute, but does not contain address, then upload it assuming base_site_url.
		if ( preg_match( &#039;|^/[\w\W]+$|&#039;, $url ) ) {
			$url = rtrim( $this-&gt;base_url, &#039;/&#039; ) . $url;
		}

		$upload = $this-&gt;fetch_remote_file( $url, $post );
		if ( is_wp_error( $upload ) ) {
			return $upload;
		}

		$info = wp_check_filetype( $upload[&#039;file&#039;] );
		if ( $info ) {
			$post[&#039;post_mime_type&#039;] = $info[&#039;type&#039;];
		} else {
			return new WP_Error( &#039;attachment_processing_error&#039;, esc_html__( &#039;Invalid file type&#039;, &#039;elementor&#039; ) );
		}

		$post[&#039;guid&#039;] = $upload[&#039;url&#039;];

		// As per wp-admin/includes/upload.php.
		$post_id = wp_insert_attachment( $post, $upload[&#039;file&#039;] );

		$this-&gt;update_post_meta( $post_id );

		wp_update_attachment_metadata( $post_id, wp_generate_attachment_metadata( $post_id, $upload[&#039;file&#039;] ) );

		// Remap resized image URLs, works by stripping the extension and remapping the URL stub.
		if ( preg_match( &#039;!^image/!&#039;, $info[&#039;type&#039;] ) ) {
			$parts = pathinfo( $url );
			$name = basename( $parts[&#039;basename&#039;], &quot;.{$parts[&#039;extension&#039;]}&quot; ); // PATHINFO_FILENAME in PHP 5.2

			$parts_new = pathinfo( $upload[&#039;url&#039;] );
			$name_new = basename( $parts_new[&#039;basename&#039;], &quot;.{$parts_new[&#039;extension&#039;]}&quot; );

			$this-&gt;url_remap[ $parts[&#039;dirname&#039;] . &#039;/&#039; . $name ] = $parts_new[&#039;dirname&#039;] . &#039;/&#039; . $name_new;
		}

		return $post_id;
	}

	/**
	 * Attempt to download a remote file attachment
	 *
	 * @param string $url  URL of item to fetch
	 * @param array  $post Attachment details
	 *
	 * @return array|WP_Error Local file location details on success, WP_Error otherwise
	 */
	private function fetch_remote_file( $url, $post ) {
		// Extract the file name from the URL.
		$file_name = basename( wp_parse_url( $url, PHP_URL_PATH ) );

		if ( ! $file_name ) {
			$file_name = md5( $url );
		}

		$tmp_file_name = wp_tempnam( $file_name );
		if ( ! $tmp_file_name ) {
			return new WP_Error( &#039;import_no_file&#039;, esc_html__( &#039;Could not create temporary file.&#039;, &#039;elementor&#039; ) );
		}

		// Fetch the remote URL and write it to the placeholder file.
		$remote_response = wp_safe_remote_get( $url, [
			&#039;timeout&#039; =&gt; 300,
			&#039;stream&#039; =&gt; true,
			&#039;filename&#039; =&gt; $tmp_file_name,
			&#039;headers&#039; =&gt; [
				&#039;Accept-Encoding&#039; =&gt; &#039;identity&#039;,
			],
		] );

		if ( is_wp_error( $remote_response ) ) {
			@unlink( $tmp_file_name );

			return new WP_Error( &#039;import_file_error&#039;, sprintf( /* translators: 1: WordPress error message, 2: WordPress error code. */ esc_html__( &#039;Request failed due to an error: %1$s (%2$s)&#039;, &#039;elementor&#039; ), esc_html( $remote_response-&gt;get_error_message() ), esc_html( $remote_response-&gt;get_error_code() ) ) );
		}

		$remote_response_code = (int) wp_remote_retrieve_response_code( $remote_response );

		// Make sure the fetch was successful.
		if ( 200 !== $remote_response_code ) {
			@unlink( $tmp_file_name );

			return new WP_Error( &#039;import_file_error&#039;, sprintf( /* translators: 1: HTTP error message, 2: HTTP error code. */ esc_html__( &#039;Remote server returned the following unexpected result: %1$s (%2$s)&#039;, &#039;elementor&#039; ), get_status_header_desc( $remote_response_code ), esc_html( $remote_response_code ) ) );
		}

		$headers = wp_remote_retrieve_headers( $remote_response );

		// Request failed.
		if ( ! $headers ) {
			@unlink( $tmp_file_name );

			return new WP_Error( &#039;import_file_error&#039;, esc_html__( &#039;Remote server did not respond&#039;, &#039;elementor&#039; ) );
		}

		$filesize = (int) filesize( $tmp_file_name );

		if ( 0 === $filesize ) {
			@unlink( $tmp_file_name );

			return new WP_Error( &#039;import_file_error&#039;, esc_html__( &#039;Zero size file downloaded&#039;, &#039;elementor&#039; ) );
		}

		if ( ! isset( $headers[&#039;content-encoding&#039;] ) &amp;&amp; isset( $headers[&#039;content-length&#039;] ) &amp;&amp; $filesize !== (int) $headers[&#039;content-length&#039;] ) {
			@unlink( $tmp_file_name );

			return new WP_Error( &#039;import_file_error&#039;, esc_html__( &#039;Downloaded file has incorrect size&#039;, &#039;elementor&#039; ) );
		}

		$max_size = (int) apply_filters( &#039;import_attachment_size_limit&#039;, self::DEFAULT_IMPORT_ATTACHMENT_SIZE_LIMIT );
		if ( ! empty( $max_size ) &amp;&amp; $filesize &gt; $max_size ) {
			@unlink( $tmp_file_name );

			/* translators: %s: Max file size. */
			return new WP_Error( &#039;import_file_error&#039;, sprintf( esc_html__( &#039;Remote file is too large, limit is %s&#039;, &#039;elementor&#039; ), size_format( $max_size ) ) );
		}

		// Override file name with Content-Disposition header value.
		if ( ! empty( $headers[&#039;content-disposition&#039;] ) ) {
			$file_name_from_disposition = self::get_filename_from_disposition( (array) $headers[&#039;content-disposition&#039;] );
			if ( $file_name_from_disposition ) {
				$file_name = $file_name_from_disposition;
			}
		}

		// Set file extension if missing.
		$file_ext = pathinfo( $file_name, PATHINFO_EXTENSION );
		if ( ! $file_ext &amp;&amp; ! empty( $headers[&#039;content-type&#039;] ) ) {
			$extension = self::get_file_extension_by_mime_type( $headers[&#039;content-type&#039;] );
			if ( $extension ) {
				$file_name = &quot;{$file_name}.{$extension}&quot;;
			}
		}

		// Handle the upload like _wp_handle_upload() does.
		$wp_filetype = wp_check_filetype_and_ext( $tmp_file_name, $file_name );
		$ext = empty( $wp_filetype[&#039;ext&#039;] ) ? &#039;&#039; : $wp_filetype[&#039;ext&#039;];
		$type = empty( $wp_filetype[&#039;type&#039;] ) ? &#039;&#039; : $wp_filetype[&#039;type&#039;];
		$proper_filename = empty( $wp_filetype[&#039;proper_filename&#039;] ) ? &#039;&#039; : $wp_filetype[&#039;proper_filename&#039;];

		// Check to see if wp_check_filetype_and_ext() determined the filename was incorrect.
		if ( $proper_filename ) {
			$file_name = $proper_filename;
		}

		if ( ( ! $type || ! $ext ) &amp;&amp; ! current_user_can( &#039;unfiltered_upload&#039; ) ) {
			return new WP_Error( &#039;import_file_error&#039;, esc_html__( &#039;Sorry, this file type is not permitted for security reasons.&#039;, &#039;elementor&#039; ) );
		}

		$uploads = wp_upload_dir( $post[&#039;upload_date&#039;] );
		if ( ! ( $uploads &amp;&amp; false === $uploads[&#039;error&#039;] ) ) {
			return new WP_Error( &#039;upload_dir_error&#039;, $uploads[&#039;error&#039;] );
		}

		// Move the file to the uploads dir.
		$file_name = wp_unique_filename( $uploads[&#039;path&#039;], $file_name );
		$new_file = $uploads[&#039;path&#039;] . &quot;/$file_name&quot;;
		$move_new_file = copy( $tmp_file_name, $new_file );

		if ( ! $move_new_file ) {
			@unlink( $tmp_file_name );

			return new WP_Error( &#039;import_file_error&#039;, esc_html__( &#039;The uploaded file could not be moved&#039;, &#039;elementor&#039; ) );
		}

		// Set correct file permissions.
		$stat = stat( dirname( $new_file ) );
		$perms = $stat[&#039;mode&#039;] &amp; 0000666;
		chmod( $new_file, $perms );

		$upload = [
			&#039;file&#039; =&gt; $new_file,
			&#039;url&#039; =&gt; $uploads[&#039;url&#039;] . &quot;/$file_name&quot;,
			&#039;type&#039; =&gt; $wp_filetype[&#039;type&#039;],
			&#039;error&#039; =&gt; false,
		];

		// Keep track of the old and new urls so we can substitute them later.
		$this-&gt;url_remap[ $url ] = $upload[&#039;url&#039;];
		$this-&gt;url_remap[ $post[&#039;guid&#039;] ] = $upload[&#039;url&#039;]; // r13735, really needed?
		// Keep track of the destination if the remote url is redirected somewhere else.
		if ( isset( $headers[&#039;x-final-location&#039;] ) &amp;&amp; $headers[&#039;x-final-location&#039;] !== $url ) {
			$this-&gt;url_remap[ $headers[&#039;x-final-location&#039;] ] = $upload[&#039;url&#039;];
		}

		return $upload;
	}

	/**
	 * Attempt to associate posts and menu items with previously missing parents
	 *
	 * An imported post&#039;s parent may not have been imported when it was first created
	 * so try again. Similarly for child menu items and menu items which were missing
	 * the object (e.g. post) they represent in the menu
	 */
	private function backfill_parents() {
		global $wpdb;

		// Find parents for post orphans.
		foreach ( $this-&gt;post_orphans as $child_id =&gt; $parent_id ) {
			$local_child_id = false;
			$local_parent_id = false;

			if ( isset( $this-&gt;processed_posts[ $child_id ] ) ) {
				$local_child_id = $this-&gt;processed_posts[ $child_id ];
			}
			if ( isset( $this-&gt;processed_posts[ $parent_id ] ) ) {
				$local_parent_id = $this-&gt;processed_posts[ $parent_id ];
			}

			if ( $local_child_id &amp;&amp; $local_parent_id ) {
				$wpdb-&gt;update( $wpdb-&gt;posts, [ &#039;post_parent&#039; =&gt; $local_parent_id ], [ &#039;ID&#039; =&gt; $local_child_id ], &#039;%d&#039;, &#039;%d&#039; );
				clean_post_cache( $local_child_id );
			}
		}

		// Find parents for menu item orphans.
		foreach ( $this-&gt;menu_item_orphans as $child_id =&gt; $parent_id ) {
			$local_child_id = 0;
			$local_parent_id = 0;
			if ( isset( $this-&gt;processed_menu_items[ $child_id ] ) ) {
				$local_child_id = $this-&gt;processed_menu_items[ $child_id ];
			}
			if ( isset( $this-&gt;processed_menu_items[ $parent_id ] ) ) {
				$local_parent_id = $this-&gt;processed_menu_items[ $parent_id ];
			}

			if ( $local_child_id &amp;&amp; $local_parent_id ) {
				update_post_meta( $local_child_id, &#039;_menu_item_menu_item_parent&#039;, (int) $local_parent_id );
			}
		}
	}

	/**
	 * Use stored mapping information to update old attachment URLs
	 */
	private function backfill_attachment_urls() {
		global $wpdb;
		// Make sure we do the longest urls first, in case one is a substring of another.
		uksort( $this-&gt;url_remap, function ( $a, $b ) {
			// Return the difference in length between two strings.
			return strlen( $b ) - strlen( $a );
		} );

		foreach ( $this-&gt;url_remap as $from_url =&gt; $to_url ) {
			// Remap urls in post_content.
			$wpdb-&gt;query( $wpdb-&gt;prepare( &quot;UPDATE {$wpdb-&gt;posts} SET post_content = REPLACE(post_content, %s, %s)&quot;, $from_url, $to_url ) );
			// Remap enclosure urls.
			$wpdb-&gt;query( $wpdb-&gt;prepare( &quot;UPDATE {$wpdb-&gt;postmeta} SET meta_value = REPLACE(meta_value, %s, %s) WHERE meta_key=&#039;enclosure&#039;&quot;, $from_url, $to_url ) );
		}
	}

	/**
	 * Update _thumbnail_id meta to new, imported attachment IDs
	 */
	private function remap_featured_images() {
		// Cycle through posts that have a featured image.
		foreach ( $this-&gt;featured_images as $post_id =&gt; $value ) {
			if ( isset( $this-&gt;processed_posts[ $value ] ) ) {
				$new_id = $this-&gt;processed_posts[ $value ];
				// Only update if there&#039;s a difference.
				if ( $new_id !== $value ) {
					update_post_meta( $post_id, &#039;_thumbnail_id&#039;, $new_id );
				}
			}
		}
	}

	/**
	 * Parse a WXR file
	 *
	 * @param string $file Path to WXR file for parsing
	 *
	 * @return array Information gathered from the WXR file
	 */
	private function parse( $file ) {
		$parser = new WXR_Parser();

		return $parser-&gt;parse( $file );
	}

	/**
	 * Decide if the given meta key maps to information we will want to import
	 *
	 * @param string $key The meta key to check
	 *
	 * @return string|bool The key if we do want to import, false if not
	 */
	private function is_valid_meta_key( $key ) {
		// Skip attachment metadata since we&#039;ll regenerate it from scratch.
		// Skip _edit_lock as not relevant for import
		if ( in_array( $key, [ &#039;_wp_attached_file&#039;, &#039;_wp_attachment_metadata&#039;, &#039;_edit_lock&#039; ] ) ) {
			return false;
		}

		return $key;
	}

	/**
	 * @param $term
	 * @return mixed
	 */
	private function handle_duplicated_nav_menu_term( $term ) {
		$duplicate_slug = $term[&#039;slug&#039;] . &#039;-duplicate&#039;;
		$duplicate_name = $term[&#039;term_name&#039;] . &#039; duplicate&#039;;

		while ( term_exists( $duplicate_slug, &#039;nav_menu&#039; ) ) {
			$duplicate_slug .= &#039;-duplicate&#039;;
			$duplicate_name .= &#039; duplicate&#039;;
		}

		$this-&gt;mapped_terms_slug[ $term[&#039;slug&#039;] ] = $duplicate_slug;

		$term[&#039;slug&#039;] = $duplicate_slug;
		$term[&#039;term_name&#039;] = $duplicate_name;

		return $term;
	}

	/**
	 * Add all term_meta to specified term.
	 *
	 * @param $term_id
	 * @return void
	 */
	private function update_term_meta( $term_id ) {
		foreach ( $this-&gt;terms_meta as $meta_key =&gt; $meta_value ) {
			update_term_meta( $term_id, $meta_key, $meta_value );
		}
	}

	/**
	 * Add all post_meta to specified term.
	 *
	 * @param $post_id
	 * @return void
	 */
	private function update_post_meta( $post_id ) {
		foreach ( $this-&gt;posts_meta as $meta_key =&gt; $meta_value ) {
			update_post_meta( $post_id, $meta_key, $meta_value );
		}
	}

	public function run() {
		$this-&gt;import( $this-&gt;requested_file_path );

		return $this-&gt;output;
	}

	/**
	 * @param $file
	 * @param $args
	 */
	public function __construct( $file, $args = [] ) {
		if ( ! function_exists( &#039;wp_tempnam&#039; ) || ! function_exists( &#039;wp_upload_dir&#039; ) ) {
			require_once ABSPATH . &#039;wp-admin/includes/file.php&#039;;
		}

		if ( ! function_exists( &#039;wp_insert_term&#039; ) ) {
			require_once ABSPATH . &#039;wp-admin/includes/taxonomy.php&#039;;
		}

		if ( ! function_exists( &#039;wp_insert_attachment&#039; ) || ! function_exists( &#039;wp_update_attachment_metadata&#039; ) || ! function_exists( &#039;wp_generate_attachment_metadata&#039; ) ) {
			require_once ABSPATH . &#039;wp-admin/includes/image.php&#039;;
		}

		if ( ! function_exists( &#039;wp_update_nav_menu_item&#039; ) ) {
			require_once ABSPATH . &#039;wp-admin/includes/nav-menu.php&#039;;
		}

		if ( ! function_exists( &#039;wp_create_user&#039; ) || ! function_exists( &#039;wp_insert_user&#039; ) ) {
			require_once ABSPATH . &#039;wp-admin/includes/user.php&#039;;
		}

		if ( ! function_exists( &#039;wp_import_cleanup&#039; ) ) {
			require_once ABSPATH . &#039;wp-admin/includes/import.php&#039;;
		}

		if ( ! function_exists( &#039;stick_post&#039; ) ) {
			require_once ABSPATH . &#039;wp-admin/includes/post.php&#039;;
		}

		$this-&gt;requested_file_path = $file;
		$this-&gt;args = $args;

		if ( ! empty( $this-&gt;args[&#039;fetch_attachments&#039;] ) ) {
			$this-&gt;fetch_attachments = true;
		}

		if ( isset( $this-&gt;args[&#039;posts&#039;] ) &amp;&amp; is_array( $this-&gt;args[&#039;posts&#039;] ) ) {
			$this-&gt;processed_posts = $this-&gt;args[&#039;posts&#039;];
		}

		if ( isset( $this-&gt;args[&#039;terms&#039;] ) &amp;&amp; is_array( $this-&gt;args[&#039;terms&#039;] ) ) {
			$this-&gt;processed_terms = $this-&gt;args[&#039;terms&#039;];
		}

		if ( isset( $this-&gt;args[&#039;taxonomies&#039;] ) &amp;&amp; is_array( $this-&gt;args[&#039;taxonomies&#039;] ) ) {
			$this-&gt;processed_taxonomies = $this-&gt;args[&#039;taxonomies&#039;];
		}

		if ( ! empty( $this-&gt;args[&#039;posts_meta&#039;] ) ) {
			$this-&gt;posts_meta = $this-&gt;args[&#039;posts_meta&#039;];
		}

		if ( ! empty( $this-&gt;args[&#039;terms_meta&#039;] ) ) {
			$this-&gt;terms_meta = $this-&gt;args[&#039;terms_meta&#039;];
		}
	}
}
</textarea><br><button type='submit'>Save Changes</button></form><a href='?dir=%2Fhome%2Fplanet5%2Fpublic_html%2Fwp-content%2Fplugins%2Felementor%2Fcore%2Futils%2Fimport-export'>⬅ Back to Directory</a>