first commit

wp-content/plugins/elementor-3.2.5-bck4/core/utils/collection.php

@@ -0,0 +1,308 @@
+<?php
+/**
+ * Inspired by Laravel Collection.
+ * @link https://github.com/illuminate/collections
+ */
+namespace Elementor\Core\Utils;
+
+if ( ! defined( 'ABSPATH' ) ) {
+	exit; // Exit if accessed directly.
+}
+
+class Collection implements \ArrayAccess, \Countable, \IteratorAggregate {
+	/**
+	 * The items contained in the collection.
+	 *
+	 * @var array
+	 */
+	protected $items;
+
+	/**
+	 * Collection constructor.
+	 *
+	 * @param array $items
+	 */
+	public function __construct( array $items ) {
+		$this->items = $items;
+	}
+
+	/**
+	 * @param callable|null $callback
+	 *
+	 * @return $this
+	 */
+	public function filter( callable $callback = null ) {
+		if ( ! $callback ) {
+			return new static( array_filter( $this->items ) );
+		}
+
+		return new static( array_filter( $this->items, $callback, ARRAY_FILTER_USE_BOTH ) );
+	}
+
+	/**
+	 * @param $items
+	 *
+	 * @return $this
+	 */
+	public function merge( $items ) {
+		if ( $items instanceof Collection ) {
+			$items = $items->all();
+		}
+
+		return new static( array_merge( $this->items, $items ) );
+	}
+
+	/**
+	 * Merge array recursively
+	 *
+	 * @param $items
+	 *
+	 * @return $this
+	 */
+	public function merge_recursive( $items ) {
+		if ( $items instanceof Collection ) {
+			$items = $items->all();
+		}
+
+		return new static( array_merge_recursive( $this->items, $items ) );
+	}
+
+	/**
+	 * Implode the items
+	 *
+	 * @param $glue
+	 *
+	 * @return string
+	 */
+	public function implode( $glue ) {
+		return implode( $glue, $this->items );
+	}
+
+	/**
+	 * Run a map over each of the items.
+	 *
+	 * @param  callable  $callback
+	 * @return $this
+	 */
+	public function map( callable $callback ) {
+		$keys = array_keys( $this->items );
+
+		$items = array_map( $callback, $this->items, $keys );
+
+		return new static( array_combine( $keys, $items ) );
+	}
+
+	/**
+	 * @param callable $callback
+	 *
+	 * @return $this
+	 */
+	public function map_with_keys( callable $callback ) {
+		$result = [];
+
+		foreach ( $this->items as $key => $value ) {
+			$assoc = $callback( $value, $key );
+
+			foreach ( $assoc as $map_key => $map_value ) {
+				$result[ $map_key ] = $map_value;
+			}
+		}
+
+		return new static( $result );
+	}
+
+	/**
+	 * Get all items except for those with the specified keys.
+	 *
+	 * @param array $keys
+	 *
+	 * @return $this
+	 */
+	public function except( array $keys ) {
+		return $this->filter( function ( $value, $key ) use ( $keys ) {
+			return ! in_array( $key, $keys, true );
+		} );
+	}
+
+	/**
+	 * Get the items with the specified keys.
+	 *
+	 * @param array $keys
+	 *
+	 * @return $this
+	 */
+	public function only( array $keys ) {
+		return $this->filter( function ( $value, $key ) use ( $keys ) {
+			return in_array( $key, $keys, true );
+		} );
+	}
+
+	/**
+	 * Run over the collection to get specific prop from the collection item.
+	 *
+	 * @param $key
+	 *
+	 * @return $this
+	 */
+	public function pluck( $key ) {
+		$result = [];
+
+		foreach ( $this->items as $value ) {
+			if ( is_object( $value ) && isset( $value->{$key} ) ) {
+				$result[] = $value->{$key};
+			} elseif ( is_array( $value ) && isset( $value[ $key ] ) ) {
+				$result[] = $value[ $key ];
+			}
+		}
+
+		return new static( $result );
+	}
+
+	/**
+	 * Group the collection items by specific key in each collection item.
+	 *
+	 * @param $group_by
+	 *
+	 * @return $this
+	 */
+	public function group_by( $group_by ) {
+		$result = [];
+
+		foreach ( $this->items as $value ) {
+			$group_key = 0;
+
+			if ( is_object( $value ) && isset( $value->{$group_by} ) ) {
+				$group_key = $value->{$group_by};
+			} elseif ( is_array( $value ) && isset( $value[ $group_by ] ) ) {
+				$group_key = $value[ $group_by ];
+			}
+
+			$result[ $group_key ][] = $value;
+		}
+
+		return new static( $result );
+	}
+
+	/**
+	 * Get specific item from the collection.
+	 *
+	 * @param      $key
+	 * @param null $default
+	 *
+	 * @return mixed|null
+	 */
+	public function get( $key, $default = null ) {
+		if ( ! array_key_exists( $key, $this->items ) ) {
+			return $default;
+		}
+
+		return $this->items[ $key ];
+	}
+
+	/**
+	 * Get the first item.
+	 *
+	 * @param null $default
+	 *
+	 * @return mixed|null
+	 */
+	public function first( $default = null ) {
+		if ( $this->is_empty() ) {
+			return $default;
+		}
+
+		foreach ( $this->items as $item ) {
+			return $item;
+		}
+	}
+
+	/**
+	 * Make sure all the values inside the array are uniques.
+	 *
+	 * @return $this
+	 */
+	public function unique() {
+		return new static(
+			array_unique( $this->items )
+		);
+	}
+
+	/**
+	 * @return array
+	 */
+	public function keys() {
+		return array_keys( $this->items );
+	}
+
+	/**
+	 * @return bool
+	 */
+	public function is_empty() {
+		return empty( $this->items );
+	}
+
+	/**
+	 * @return array
+	 */
+	public function all() {
+		return $this->items;
+	}
+
+	/**
+	 * @return array
+	 */
+	public function values() {
+		return array_values( $this->all() );
+	}
+
+	/**
+	 * @param mixed $key
+	 *
+	 * @return bool
+	 */
+	public function offsetExists( $key ) {
+		return isset( $this->items[ $key ] );
+	}
+
+	/**
+	 * @param mixed $key
+	 *
+	 * @return mixed
+	 */
+	public function offsetGet( $key ) {
+		return $this->items[ $key ];
+	}
+
+	/**
+	 * @param mixed $key
+	 * @param mixed $value
+	 */
+	public function offsetSet( $key, $value ) {
+		if ( is_null( $key ) ) {
+			$this->items[] = $value;
+		} else {
+			$this->items[ $key ] = $value;
+		}
+	}
+
+	/**
+	 * @param mixed $key
+	 */
+	public function offsetUnset( $key ) {
+		unset( $this->items[ $key ] );
+	}
+
+	/**
+	 * @return \ArrayIterator|\Traversable
+	 */
+	public function getIterator() {
+		return new \ArrayIterator( $this->items );
+	}
+
+	/**
+	 * @return int|void
+	 */
+	public function count() {
+		return count( $this->items );
+	}
+}

wp-content/plugins/elementor-3.2.5-bck4/core/utils/exceptions.php

@@ -0,0 +1,41 @@
+<?php
+namespace Elementor\Core\Utils;
+
+if ( ! defined( 'ABSPATH' ) ) {
+	exit; // Exit if accessed directly
+}
+
+/**
+ * Elementor exceptions.
+ *
+ * Elementor exceptions handler class is responsible for handling exceptions.
+ *
+ * @since 2.0.0
+ */
+class Exceptions {
+
+	/**
+	 * HTTP status code for bad request error.
+	 */
+	const BAD_REQUEST = 400;
+
+	/**
+	 * HTTP status code for unauthorized access error.
+	 */
+	const UNAUTHORIZED = 401;
+
+	/**
+	 * HTTP status code for forbidden access error.
+	 */
+	const FORBIDDEN = 403;
+
+	/**
+	 * HTTP status code for resource that could not be found.
+	 */
+	const NOT_FOUND = 404;
+
+	/**
+	 * HTTP status code for internal server error.
+	 */
+	const INTERNAL_SERVER_ERROR = 500;
+}

wp-content/plugins/elementor-3.2.5-bck4/core/utils/import-export/parsers/wxr-parser-regex.php

@@ -0,0 +1,387 @@
+<?php
+namespace Elementor\Core\Utils\ImportExport\Parsers;
+
+use WP_Error;
+
+if ( ! defined( 'ABSPATH' ) ) {
+	exit; // Exit if accessed directly.
+}
+
+/**
+ * WordPress eXtended RSS file parser implementations
+ * Originally made by WordPress part of WordPress/Importer.
+ * https://plugins.trac.wordpress.org/browser/wordpress-importer/trunk/parsers/class-wxr-parser-regex.php
+ *
+ * What was done:
+ * Reformat of the code.
+ * Changed text domain.
+ * Changed methods visibility.
+ */
+
+/**
+ * WXR Parser that uses regular expressions. Fallback for installs without an XML parser.
+ */
+class WXR_Parser_Regex {
+	/**
+	 * @var bool
+	 */
+	private $has_gzip;
+
+	private $authors = [];
+	private $posts = [];
+	private $categories = [];
+	private $tags = [];
+	private $terms = [];
+	private $base_url = '';
+	private $base_blog_url = '';
+
+	/**
+	 * @param string $file
+	 *
+	 * @return array|\WP_Error
+	 */
+	public function parse( $file ) {
+		$wxr_version = '';
+		$in_multiline = false;
+
+		$multiline_content = '';
+
+		$multiline_tags = [
+			'item' => [
+				'posts',
+				function ( $post ) {
+					return $this->process_post( $post );
+				},
+			],
+			'wp:category' => [
+				'categories',
+				function ( $category ) {
+					return $this->process_category( $category );
+				},
+			],
+			'wp:tag' => [
+				'tags',
+				function ( $tag ) {
+					return $this->process_tag( $tag );
+				},
+			],
+			'wp:term' => [
+				'terms',
+				function ( $term ) {
+					return $this->process_term( $term );
+				},
+			],
+		];
+
+		$fp = $this->fopen( $file, 'r' );
+		if ( $fp ) {
+			while ( ! $this->feof( $fp ) ) {
+				$importline = rtrim( $this->fgets( $fp ) );
+
+				if ( ! $wxr_version && preg_match( '|<wp:wxr_version>(\d+\.\d+)</wp:wxr_version>|', $importline, $version ) ) {
+					$wxr_version = $version[1];
+				}
+
+				if ( false !== strpos( $importline, '<wp:base_site_url>' ) ) {
+					preg_match( '|<wp:base_site_url>(.*?)</wp:base_site_url>|is', $importline, $url );
+					$this->base_url = $url[1];
+					continue;
+				}
+
+				if ( false !== strpos( $importline, '<wp:base_blog_url>' ) ) {
+					preg_match( '|<wp:base_blog_url>(.*?)</wp:base_blog_url>|is', $importline, $blog_url );
+					$this->base_blog_url = $blog_url[1];
+					continue;
+				} else {
+					$this->base_blog_url = $this->base_url;
+				}
+
+				if ( false !== strpos( $importline, '<wp:author>' ) ) {
+					preg_match( '|<wp:author>(.*?)</wp:author>|is', $importline, $author );
+					$a = $this->process_author( $author[1] );
+					$this->authors[ $a['author_login'] ] = $a;
+					continue;
+				}
+
+				foreach ( $multiline_tags as $tag => $handler ) {
+					// Handle multi-line tags on a singular line.
+					if ( preg_match( '|<' . $tag . '>(.*?)</' . $tag . '>|is', $importline, $matches ) ) {
+						$this->{$handler[0]}[] = call_user_func( $handler[1], $matches[1] );
+
+						continue;
+					}
+
+					$pos = strpos( $importline, "<$tag>" );
+
+					if ( false !== $pos ) {
+						// Take note of any content after the opening tag.
+						$multiline_content = trim( substr( $importline, $pos + strlen( $tag ) + 2 ) );
+
+						// We don't want to have this line added to `$is_multiline` below.
+						$importline = '';
+						$in_multiline = $tag;
+
+						continue;
+					}
+
+					$pos = strpos( $importline, "</$tag>" );
+
+					if ( false !== $pos ) {
+						$in_multiline = false;
+						$multiline_content .= trim( substr( $importline, 0, $pos ) );
+
+						$this->{$handler[0]}[] = call_user_func( $handler[1], $multiline_content );
+					}
+				}
+
+				if ( $in_multiline && $importline ) {
+					$multiline_content .= $importline . "\n";
+				}
+			}
+
+			$this->fclose( $fp );
+		}
+
+		if ( ! $wxr_version ) {
+			return new WP_Error( 'WXR_parse_error', __( 'This does not appear to be a WXR file, missing/invalid WXR version number', 'elementor' ) );
+		}
+
+		return [
+			'authors' => $this->authors,
+			'posts' => $this->posts,
+			'categories' => $this->categories,
+			'tags' => $this->tags,
+			'terms' => $this->terms,
+			'base_url' => $this->base_url,
+			'base_blog_url' => $this->base_blog_url,
+			'version' => $wxr_version,
+		];
+	}
+
+	private function process_category( $category ) {
+		$term = [
+			'term_id' => $this->get_tag( $category, 'wp:term_id' ),
+			'cat_name' => $this->get_tag( $category, 'wp:cat_name' ),
+			'category_nicename' => $this->get_tag( $category, 'wp:category_nicename' ),
+			'category_parent' => $this->get_tag( $category, 'wp:category_parent' ),
+			'category_description' => $this->get_tag( $category, 'wp:category_description' ),
+		];
+
+		$term_meta = $this->process_meta( $category, 'wp:termmeta' );
+		if ( ! empty( $term_meta ) ) {
+			$term['termmeta'] = $term_meta;
+		}
+
+		return $term;
+	}
+
+	private function process_tag( $tag ) {
+		$term = [
+			'term_id' => $this->get_tag( $tag, 'wp:term_id' ),
+			'tag_name' => $this->get_tag( $tag, 'wp:tag_name' ),
+			'tag_slug' => $this->get_tag( $tag, 'wp:tag_slug' ),
+			'tag_description' => $this->get_tag( $tag, 'wp:tag_description' ),
+		];
+
+		$term_meta = $this->process_meta( $tag, 'wp:termmeta' );
+		if ( ! empty( $term_meta ) ) {
+			$term['termmeta'] = $term_meta;
+		}
+
+		return $term;
+	}
+
+	private function process_term( $term ) {
+		$term_data = [
+			'term_id' => $this->get_tag( $term, 'wp:term_id' ),
+			'term_taxonomy' => $this->get_tag( $term, 'wp:term_taxonomy' ),
+			'slug' => $this->get_tag( $term, 'wp:term_slug' ),
+			'term_parent' => $this->get_tag( $term, 'wp:term_parent' ),
+			'term_name' => $this->get_tag( $term, 'wp:term_name' ),
+			'term_description' => $this->get_tag( $term, 'wp:term_description' ),
+		];
+
+		$term_meta = $this->process_meta( $term, 'wp:termmeta' );
+		if ( ! empty( $term_meta ) ) {
+			$term_data['termmeta'] = $term_meta;
+		}
+
+		return $term_data;
+	}
+
+	private function process_meta( $string, $tag ) {
+		$parsed_meta = [];
+
+		preg_match_all( "|<$tag>(.+?)</$tag>|is", $string, $meta );
+
+		if ( ! isset( $meta[1] ) ) {
+			return $parsed_meta;
+		}
+
+		foreach ( $meta[1] as $m ) {
+			$parsed_meta[] = [
+				'key' => $this->get_tag( $m, 'wp:meta_key' ),
+				'value' => $this->get_tag( $m, 'wp:meta_value' ),
+			];
+		}
+
+		return $parsed_meta;
+	}
+
+	private function process_author( $a ) {
+		return [
+			'author_id' => $this->get_tag( $a, 'wp:author_id' ),
+			'author_login' => $this->get_tag( $a, 'wp:author_login' ),
+			'author_email' => $this->get_tag( $a, 'wp:author_email' ),
+			'author_display_name' => $this->get_tag( $a, 'wp:author_display_name' ),
+			'author_first_name' => $this->get_tag( $a, 'wp:author_first_name' ),
+			'author_last_name' => $this->get_tag( $a, 'wp:author_last_name' ),
+		];
+	}
+
+	private function process_post( $post ) {
+		$normalize_tag_callback = function ( $matches ) {
+			return $this->normalize_tag( $matches );
+		};
+
+		$post_id = $this->get_tag( $post, 'wp:post_id' );
+		$post_title = $this->get_tag( $post, 'title' );
+		$post_date = $this->get_tag( $post, 'wp:post_date' );
+		$post_date_gmt = $this->get_tag( $post, 'wp:post_date_gmt' );
+		$comment_status = $this->get_tag( $post, 'wp:comment_status' );
+		$ping_status = $this->get_tag( $post, 'wp:ping_status' );
+		$status = $this->get_tag( $post, 'wp:status' );
+		$post_name = $this->get_tag( $post, 'wp:post_name' );
+		$post_parent = $this->get_tag( $post, 'wp:post_parent' );
+		$menu_order = $this->get_tag( $post, 'wp:menu_order' );
+		$post_type = $this->get_tag( $post, 'wp:post_type' );
+		$post_password = $this->get_tag( $post, 'wp:post_password' );
+		$is_sticky = $this->get_tag( $post, 'wp:is_sticky' );
+		$guid = $this->get_tag( $post, 'guid' );
+		$post_author = $this->get_tag( $post, 'dc:creator' );
+
+		$post_excerpt = $this->get_tag( $post, 'excerpt:encoded' );
+		$post_excerpt = preg_replace_callback( '|<(/?[A-Z]+)|', $normalize_tag_callback, $post_excerpt );
+		$post_excerpt = str_replace( '<br>', '<br />', $post_excerpt );
+		$post_excerpt = str_replace( '<hr>', '<hr />', $post_excerpt );
+
+		$post_content = $this->get_tag( $post, 'content:encoded' );
+		$post_content = preg_replace_callback( '|<(/?[A-Z]+)|', $normalize_tag_callback, $post_content );
+		$post_content = str_replace( '<br>', '<br />', $post_content );
+		$post_content = str_replace( '<hr>', '<hr />', $post_content );
+
+		$postdata = compact( 'post_id', 'post_author', 'post_date', 'post_date_gmt', 'post_content', 'post_excerpt', 'post_title', 'status', 'post_name', 'comment_status', 'ping_status', 'guid', 'post_parent', 'menu_order', 'post_type', 'post_password', 'is_sticky' );
+
+		$attachment_url = $this->get_tag( $post, 'wp:attachment_url' );
+		if ( $attachment_url ) {
+			$postdata['attachment_url'] = $attachment_url;
+		}
+
+		preg_match_all( '|<category domain="([^"]+?)" nicename="([^"]+?)">(.+?)</category>|is', $post, $terms, PREG_SET_ORDER );
+		foreach ( $terms as $t ) {
+			$post_terms[] = [
+				'slug' => $t[2],
+				'domain' => $t[1],
+				'name' => str_replace( [ '<![CDATA[', ']]>' ], '', $t[3] ),
+			];
+		}
+		if ( ! empty( $post_terms ) ) {
+			$postdata['terms'] = $post_terms;
+		}
+
+		preg_match_all( '|<wp:comment>(.+?)</wp:comment>|is', $post, $comments );
+		$comments = $comments[1];
+		if ( $comments ) {
+			foreach ( $comments as $comment ) {
+				$post_comments[] = [
+					'comment_id' => $this->get_tag( $comment, 'wp:comment_id' ),
+					'comment_author' => $this->get_tag( $comment, 'wp:comment_author' ),
+					'comment_author_email' => $this->get_tag( $comment, 'wp:comment_author_email' ),
+					'comment_author_IP' => $this->get_tag( $comment, 'wp:comment_author_IP' ),
+					'comment_author_url' => $this->get_tag( $comment, 'wp:comment_author_url' ),
+					'comment_date' => $this->get_tag( $comment, 'wp:comment_date' ),
+					'comment_date_gmt' => $this->get_tag( $comment, 'wp:comment_date_gmt' ),
+					'comment_content' => $this->get_tag( $comment, 'wp:comment_content' ),
+					'comment_approved' => $this->get_tag( $comment, 'wp:comment_approved' ),
+					'comment_type' => $this->get_tag( $comment, 'wp:comment_type' ),
+					'comment_parent' => $this->get_tag( $comment, 'wp:comment_parent' ),
+					'comment_user_id' => $this->get_tag( $comment, 'wp:comment_user_id' ),
+					'commentmeta' => $this->process_meta( $comment, 'wp:commentmeta' ),
+				];
+			}
+		}
+		if ( ! empty( $post_comments ) ) {
+			$postdata['comments'] = $post_comments;
+		}
+
+		$post_meta = $this->process_meta( $post, 'wp:postmeta' );
+		if ( ! empty( $post_meta ) ) {
+			$postdata['postmeta'] = $post_meta;
+		}
+
+		return $postdata;
+	}
+
+	private function get_tag( $string, $tag ) {
+		preg_match( "|<$tag.*?>(.*?)</$tag>|is", $string, $return );
+		if ( isset( $return[1] ) ) {
+			if ( substr( $return[1], 0, 9 ) == '<![CDATA[' ) {
+				if ( strpos( $return[1], ']]]]><![CDATA[>' ) !== false ) {
+					preg_match_all( '|<!\[CDATA\[(.*?)\]\]>|s', $return[1], $matches );
+					$return = '';
+					foreach ( $matches[1] as $match ) {
+						$return .= $match;
+					}
+				} else {
+					$return = preg_replace( '|^<!\[CDATA\[(.*)\]\]>$|s', '$1', $return[1] );
+				}
+			} else {
+				$return = $return[1];
+			}
+		} else {
+			$return = '';
+		}
+
+		return $return;
+	}
+
+	private function normalize_tag( $matches ) {
+		return '<' . strtolower( $matches[1] );
+	}
+
+	private function fopen( $filename, $mode = 'r' ) {
+		if ( $this->has_gzip ) {
+			return gzopen( $filename, $mode );
+		}
+
+		return fopen( $filename, $mode );
+	}
+
+	private function feof( $fp ) {
+		if ( $this->has_gzip ) {
+			return gzeof( $fp );
+		}
+
+		return feof( $fp );
+	}
+
+	private function fgets( $fp, $len = 8192 ) {
+		if ( $this->has_gzip ) {
+			return gzgets( $fp, $len );
+		}
+
+		return fgets( $fp, $len );
+	}
+
+	private function fclose( $fp ) {
+		if ( $this->has_gzip ) {
+			return gzclose( $fp );
+		}
+
+		return fclose( $fp );
+	}
+
+	public function __construct() {
+		$this->has_gzip = is_callable( 'gzopen' );
+	}
+}

wp-content/plugins/elementor-3.2.5-bck4/core/utils/import-export/parsers/wxr-parser-simple-xml.php

@@ -0,0 +1,264 @@
+<?php
+namespace Elementor\Core\Utils\ImportExport\Parsers;
+
+use WP_Error;
+
+if ( ! defined( 'ABSPATH' ) ) {
+	exit; // Exit if accessed directly.
+}
+
+/**
+ * WordPress eXtended RSS file parser implementations,
+ * Originally made by WordPress part of WordPress/Importer.
+ * https://plugins.trac.wordpress.org/browser/wordpress-importer/trunk/parsers/class-wxr-parser-simplexml.php
+ *
+ * What was done:
+ * Reformat of the code.
+ * Removed variable '$internal_errors'.
+ * Changed text domain.
+ */
+
+/**
+ * WXR Parser that makes use of the SimpleXML PHP extension.
+ */
+class WXR_Parser_SimpleXML {
+
+	/**
+	 * @param string $file
+	 *
+	 * @return array|\WP_Error
+	 */
+	public function parse( $file ) {
+		$authors = [];
+		$posts = [];
+		$categories = [];
+		$tags = [];
+		$terms = [];
+
+		libxml_use_internal_errors( true );
+
+		$dom = new \DOMDocument();
+		$old_value = null;
+
+		$libxml_disable_entity_loader_exists = function_exists( 'libxml_disable_entity_loader' );
+
+		if ( $libxml_disable_entity_loader_exists ) {
+			$old_value = libxml_disable_entity_loader( true ); // phpcs:ignore Generic.PHP.DeprecatedFunctions.Deprecated
+		}
+
+		$success = $dom->loadXML( file_get_contents( $file ) );
+
+		if ( $libxml_disable_entity_loader_exists && ! is_null( $old_value ) ) {
+			libxml_disable_entity_loader( $old_value ); // phpcs:ignore Generic.PHP.DeprecatedFunctions.Deprecated
+		}
+
+		if ( ! $success || isset( $dom->doctype ) ) {
+			return new WP_Error( 'SimpleXML_parse_error', __( 'There was an error when reading this WXR file', 'elementor' ), libxml_get_errors() );
+		}
+
+		$xml = simplexml_import_dom( $dom );
+		unset( $dom );
+
+		// Halt if loading produces an error.
+		if ( ! $xml ) {
+			return new WP_Error( 'SimpleXML_parse_error', __( 'There was an error when reading this WXR file', 'elementor' ), libxml_get_errors() );
+		}
+
+		$wxr_version = $xml->xpath( '/rss/channel/wp:wxr_version' );
+		if ( ! $wxr_version ) {
+			return new WP_Error( 'WXR_parse_error', __( 'This does not appear to be a WXR file, missing/invalid WXR version number', 'elementor' ) );
+		}
+
+		$wxr_version = (string) trim( $wxr_version[0] );
+		// Confirm that we are dealing with the correct file format.
+		if ( ! preg_match( '/^\d+\.\d+$/', $wxr_version ) ) {
+			return new WP_Error( 'WXR_parse_error', __( 'This does not appear to be a WXR file, missing/invalid WXR version number', 'elementor' ) );
+		}
+
+		$base_url = $xml->xpath( '/rss/channel/wp:base_site_url' );
+		$base_url = (string) trim( isset( $base_url[0] ) ? $base_url[0] : '' );
+
+		$base_blog_url = $xml->xpath( '/rss/channel/wp:base_blog_url' );
+		if ( $base_blog_url ) {
+			$base_blog_url = (string) trim( $base_blog_url[0] );
+		} else {
+			$base_blog_url = $base_url;
+		}
+
+		$namespaces = $xml->getDocNamespaces();
+		if ( ! isset( $namespaces['wp'] ) ) {
+			$namespaces['wp'] = 'http://wordpress.org/export/1.1/';
+		}
+		if ( ! isset( $namespaces['excerpt'] ) ) {
+			$namespaces['excerpt'] = 'http://wordpress.org/export/1.1/excerpt/';
+		}
+
+		// Grab authors.
+		foreach ( $xml->xpath( '/rss/channel/wp:author' ) as $author_arr ) {
+			$a = $author_arr->children( $namespaces['wp'] );
+			$login = (string) $a->author_login;
+			$authors[ $login ] = [
+				'author_id' => (int) $a->author_id,
+				'author_login' => $login,
+				'author_email' => (string) $a->author_email,
+				'author_display_name' => (string) $a->author_display_name,
+				'author_first_name' => (string) $a->author_first_name,
+				'author_last_name' => (string) $a->author_last_name,
+			];
+		}
+
+		// Grab cats, tags and terms.
+		foreach ( $xml->xpath( '/rss/channel/wp:category' ) as $term_arr ) {
+			$t = $term_arr->children( $namespaces['wp'] );
+			$category = [
+				'term_id' => (int) $t->term_id,
+				'category_nicename' => (string) $t->category_nicename,
+				'category_parent' => (string) $t->category_parent,
+				'cat_name' => (string) $t->cat_name,
+				'category_description' => (string) $t->category_description,
+			];
+
+			foreach ( $t->termmeta as $meta ) {
+				$category['termmeta'][] = [
+					'key' => (string) $meta->meta_key,
+					'value' => (string) $meta->meta_value,
+				];
+			}
+
+			$categories[] = $category;
+		}
+
+		foreach ( $xml->xpath( '/rss/channel/wp:tag' ) as $term_arr ) {
+			$t = $term_arr->children( $namespaces['wp'] );
+			$tag = [
+				'term_id' => (int) $t->term_id,
+				'tag_slug' => (string) $t->tag_slug,
+				'tag_name' => (string) $t->tag_name,
+				'tag_description' => (string) $t->tag_description,
+			];
+
+			foreach ( $t->termmeta as $meta ) {
+				$tag['termmeta'][] = [
+					'key' => (string) $meta->meta_key,
+					'value' => (string) $meta->meta_value,
+				];
+			}
+
+			$tags[] = $tag;
+		}
+
+		foreach ( $xml->xpath( '/rss/channel/wp:term' ) as $term_arr ) {
+			$t = $term_arr->children( $namespaces['wp'] );
+			$term = [
+				'term_id' => (int) $t->term_id,
+				'term_taxonomy' => (string) $t->term_taxonomy,
+				'slug' => (string) $t->term_slug,
+				'term_parent' => (string) $t->term_parent,
+				'term_name' => (string) $t->term_name,
+				'term_description' => (string) $t->term_description,
+			];
+
+			foreach ( $t->termmeta as $meta ) {
+				$term['termmeta'][] = [
+					'key' => (string) $meta->meta_key,
+					'value' => (string) $meta->meta_value,
+				];
+			}
+
+			$terms[] = $term;
+		}
+
+		// Grab posts.
+		foreach ( $xml->channel->item as $item ) {
+			$post = [
+				'post_title' => (string) $item->title,
+				'guid' => (string) $item->guid,
+			];
+
+			$dc = $item->children( 'http://purl.org/dc/elements/1.1/' );
+			$post['post_author'] = (string) $dc->creator;
+
+			$content = $item->children( 'http://purl.org/rss/1.0/modules/content/' );
+			$excerpt = $item->children( $namespaces['excerpt'] );
+			$post['post_content'] = (string) $content->encoded;
+			$post['post_excerpt'] = (string) $excerpt->encoded;
+
+			$wp = $item->children( $namespaces['wp'] );
+			$post['post_id'] = (int) $wp->post_id;
+			$post['post_date'] = (string) $wp->post_date;
+			$post['post_date_gmt'] = (string) $wp->post_date_gmt;
+			$post['comment_status'] = (string) $wp->comment_status;
+			$post['ping_status'] = (string) $wp->ping_status;
+			$post['post_name'] = (string) $wp->post_name;
+			$post['status'] = (string) $wp->status;
+			$post['post_parent'] = (int) $wp->post_parent;
+			$post['menu_order'] = (int) $wp->menu_order;
+			$post['post_type'] = (string) $wp->post_type;
+			$post['post_password'] = (string) $wp->post_password;
+			$post['is_sticky'] = (int) $wp->is_sticky;
+
+			if ( isset( $wp->attachment_url ) ) {
+				$post['attachment_url'] = (string) $wp->attachment_url;
+			}
+
+			foreach ( $item->category as $c ) {
+				$att = $c->attributes();
+				if ( isset( $att['nicename'] ) ) {
+					$post['terms'][] = [
+						'name' => (string) $c,
+						'slug' => (string) $att['nicename'],
+						'domain' => (string) $att['domain'],
+					];
+				}
+			}
+
+			foreach ( $wp->postmeta as $meta ) {
+				$post['postmeta'][] = [
+					'key' => (string) $meta->meta_key,
+					'value' => (string) $meta->meta_value,
+				];
+			}
+
+			foreach ( $wp->comment as $comment ) {
+				$meta = [];
+				if ( isset( $comment->commentmeta ) ) {
+					foreach ( $comment->commentmeta as $m ) {
+						$meta[] = [
+							'key' => (string) $m->meta_key,
+							'value' => (string) $m->meta_value,
+						];
+					}
+				}
+
+				$post['comments'][] = [
+					'comment_id' => (int) $comment->comment_id,
+					'comment_author' => (string) $comment->comment_author,
+					'comment_author_email' => (string) $comment->comment_author_email,
+					'comment_author_IP' => (string) $comment->comment_author_IP,
+					'comment_author_url' => (string) $comment->comment_author_url,
+					'comment_date' => (string) $comment->comment_date,
+					'comment_date_gmt' => (string) $comment->comment_date_gmt,
+					'comment_content' => (string) $comment->comment_content,
+					'comment_approved' => (string) $comment->comment_approved,
+					'comment_type' => (string) $comment->comment_type,
+					'comment_parent' => (string) $comment->comment_parent,
+					'comment_user_id' => (int) $comment->comment_user_id,
+					'commentmeta' => $meta,
+				];
+			}
+
+			$posts[] = $post;
+		}
+
+		return [
+			'authors' => $authors,
+			'posts' => $posts,
+			'categories' => $categories,
+			'tags' => $tags,
+			'terms' => $terms,
+			'base_url' => $base_url,
+			'base_blog_url' => $base_blog_url,
+			'version' => $wxr_version,
+		];
+	}
+}

wp-content/plugins/elementor-3.2.5-bck4/core/utils/import-export/parsers/wxr-parser-xml.php

@@ -0,0 +1,363 @@
+<?php
+namespace Elementor\Core\Utils\ImportExport\Parsers;
+
+use WP_Error;
+
+if ( ! defined( 'ABSPATH' ) ) {
+	exit; // Exit if accessed directly.
+}
+
+/**
+ * WordPress eXtended RSS file parser implementations,
+ * Originally made by WordPress part of WordPress/Importer.
+ * https://plugins.trac.wordpress.org/browser/wordpress-importer/trunk/parsers/class-wxr-parser-xml.php
+ *
+ * What was done:
+ * Reformat of the code.
+ * Added PHPDOC.
+ * Changed text domain.
+ * Added clear() method.
+ * Added undeclared class properties.
+ * Changed methods visibility.
+ */
+
+/**
+ * WXR Parser that makes use of the XML Parser PHP extension.
+ */
+class WXR_Parser_XML {
+	private static $wp_tags = [
+		'wp:post_id',
+		'wp:post_date',
+		'wp:post_date_gmt',
+		'wp:comment_status',
+		'wp:ping_status',
+		'wp:attachment_url',
+		'wp:status',
+		'wp:post_name',
+		'wp:post_parent',
+		'wp:menu_order',
+		'wp:post_type',
+		'wp:post_password',
+		'wp:is_sticky',
+		'wp:term_id',
+		'wp:category_nicename',
+		'wp:category_parent',
+		'wp:cat_name',
+		'wp:category_description',
+		'wp:tag_slug',
+		'wp:tag_name',
+		'wp:tag_description',
+		'wp:term_taxonomy',
+		'wp:term_parent',
+		'wp:term_name',
+		'wp:term_description',
+		'wp:author_id',
+		'wp:author_login',
+		'wp:author_email',
+		'wp:author_display_name',
+		'wp:author_first_name',
+		'wp:author_last_name',
+	];
+
+	private static $wp_sub_tags = [
+		'wp:comment_id',
+		'wp:comment_author',
+		'wp:comment_author_email',
+		'wp:comment_author_url',
+		'wp:comment_author_IP',
+		'wp:comment_date',
+		'wp:comment_date_gmt',
+		'wp:comment_content',
+		'wp:comment_approved',
+		'wp:comment_type',
+		'wp:comment_parent',
+		'wp:comment_user_id',
+	];
+
+	/**
+	 * @var string
+	 */
+	private $wxr_version;
+
+	/**
+	 * @var string
+	 */
+	private $cdata;
+
+	/**
+	 * @var array
+	 */
+	private $data;
+
+	/**
+	 * @var array
+	 */
+	private $sub_data;
+
+	/**
+	 * @var boolean
+	 */
+	private $in_post;
+
+	/**
+	 * @var boolean
+	 */
+	private $in_tag;
+
+	/**
+	 * @var boolean
+	 */
+	private $in_sub_tag;
+
+	/**
+	 * @var array
+	 */
+	private $authors;
+
+	/**
+	 * @var array
+	 */
+	private $posts;
+
+	/**
+	 * @var array
+	 */
+	private $term;
+
+	/**
+	 * @var array
+	 */
+	private $category;
+
+	/**
+	 * @var array
+	 */
+	private $tag;
+
+	/**
+	 * @var string
+	 */
+	private $base_url;
+
+	/**
+	 * @var string
+	 */
+	private $base_blog_url;
+
+	/**
+	 * @param string $file
+	 *
+	 * @return array|WP_Error
+	 */
+	public function parse( $file ) {
+		$this->clear();
+
+		$xml = xml_parser_create( 'UTF-8' );
+		xml_parser_set_option( $xml, XML_OPTION_SKIP_WHITE, 1 );
+		xml_parser_set_option( $xml, XML_OPTION_CASE_FOLDING, 0 );
+		xml_set_object( $xml, $this );
+
+		xml_set_character_data_handler( $xml, function ( $parser, $cdata ) {
+			$this->cdata( $cdata );
+		} );
+
+		$tag_open_callback = function ( $parse, $tag, $attr ) {
+			$this->tag_open( $tag, $attr );
+		};
+
+		$tag_close_callback = function ( $parser, $tag ) {
+			$this->tag_close( $tag );
+		};
+
+		xml_set_element_handler( $xml, $tag_open_callback, $tag_close_callback );
+
+		if ( ! xml_parse( $xml, file_get_contents( $file ), true ) ) {
+			$current_line = xml_get_current_line_number( $xml );
+			$current_column = xml_get_current_column_number( $xml );
+			$error_code = xml_get_error_code( $xml );
+			$error_string = xml_error_string( $error_code );
+
+			return new WP_Error( 'XML_parse_error', 'There was an error when reading this WXR file', [
+				$current_line,
+				$current_column,
+				$error_string,
+			] );
+		}
+		xml_parser_free( $xml );
+
+		if ( ! preg_match( '/^\d+\.\d+$/', $this->wxr_version ) ) {
+			return new WP_Error( 'WXR_parse_error', __( 'This does not appear to be a WXR file, missing/invalid WXR version number', 'elementor' ) );
+		}
+
+		return array(
+			'authors' => $this->authors,
+			'posts' => $this->posts,
+			'categories' => $this->category,
+			'tags' => $this->tag,
+			'terms' => $this->term,
+			'base_url' => $this->base_url,
+			'base_blog_url' => $this->base_blog_url,
+			'version' => $this->wxr_version,
+		);
+	}
+
+	private function tag_open( $tag, $attr ) {
+		if ( in_array( $tag, self::$wp_tags ) ) {
+			$this->in_tag = substr( $tag, 3 );
+
+			return;
+		}
+
+		if ( in_array( $tag, self::$wp_sub_tags ) ) {
+			$this->in_sub_tag = substr( $tag, 3 );
+
+			return;
+		}
+
+		switch ( $tag ) {
+			case 'category':
+				if ( isset( $attr['domain'], $attr['nicename'] ) ) {
+					$this->sub_data['domain'] = $attr['domain'];
+					$this->sub_data['slug'] = $attr['nicename'];
+				}
+				break;
+			case 'item':
+				$this->in_post = true;
+				// No break !!!.
+			case 'title':
+				if ( $this->in_post ) {
+					$this->in_tag = 'post_title';
+				}
+				break;
+			case 'guid':
+				$this->in_tag = 'guid';
+				break;
+			case 'dc:creator':
+				$this->in_tag = 'post_author';
+				break;
+			case 'content:encoded':
+				$this->in_tag = 'post_content';
+				break;
+			case 'excerpt:encoded':
+				$this->in_tag = 'post_excerpt';
+				break;
+
+			case 'wp:term_slug':
+				$this->in_tag = 'slug';
+				break;
+			case 'wp:meta_key':
+				$this->in_sub_tag = 'key';
+				break;
+			case 'wp:meta_value':
+				$this->in_sub_tag = 'value';
+				break;
+		}
+	}
+
+	private function cdata( $cdata ) {
+		if ( ! trim( $cdata ) ) {
+			return;
+		}
+
+		if ( false !== $this->in_tag || false !== $this->in_sub_tag ) {
+			$this->cdata .= $cdata;
+		} else {
+			$this->cdata .= trim( $cdata );
+		}
+	}
+
+	private function tag_close( $tag ) {
+		switch ( $tag ) {
+			case 'wp:comment':
+				unset( $this->sub_data['key'], $this->sub_data['value'] ); // Remove meta sub_data.
+				if ( ! empty( $this->sub_data ) ) {
+					$this->data['comments'][] = $this->sub_data;
+				}
+				$this->sub_data = [];
+				break;
+			case 'wp:commentmeta':
+				$this->sub_data['commentmeta'][] = [
+					'key' => $this->sub_data['key'],
+					'value' => $this->sub_data['value'],
+				];
+				break;
+			case 'category':
+				if ( ! empty( $this->sub_data ) ) {
+					$this->sub_data['name'] = $this->cdata;
+					$this->data['terms'][] = $this->sub_data;
+				}
+				$this->sub_data = [];
+				break;
+			case 'wp:postmeta':
+				if ( ! empty( $this->sub_data ) ) {
+					$this->data['postmeta'][] = $this->sub_data;
+				}
+				$this->sub_data = [];
+				break;
+			case 'item':
+				$this->posts[] = $this->data;
+				$this->data = [];
+				break;
+			case 'wp:category':
+			case 'wp:tag':
+			case 'wp:term':
+				$n = substr( $tag, 3 );
+				array_push( $this->$n, $this->data );
+				$this->data = [];
+				break;
+			case 'wp:termmeta':
+				if ( ! empty( $this->sub_data ) ) {
+					$this->data['termmeta'][] = $this->sub_data;
+				}
+				$this->sub_data = [];
+				break;
+			case 'wp:author':
+				if ( ! empty( $this->data['author_login'] ) ) {
+					$this->authors[ $this->data['author_login'] ] = $this->data;
+				}
+				$this->data = [];
+				break;
+			case 'wp:base_site_url':
+				$this->base_url = $this->cdata;
+				if ( ! isset( $this->base_blog_url ) ) {
+					$this->base_blog_url = $this->cdata;
+				}
+				break;
+			case 'wp:base_blog_url':
+				$this->base_blog_url = $this->cdata;
+				break;
+			case 'wp:wxr_version':
+				$this->wxr_version = $this->cdata;
+				break;
+
+			default:
+				if ( $this->in_sub_tag ) {
+					$this->sub_data[ $this->in_sub_tag ] = $this->cdata;
+					$this->in_sub_tag = false;
+				} else if ( $this->in_tag ) {
+					$this->data[ $this->in_tag ] = $this->cdata;
+					$this->in_tag = false;
+				}
+		}
+
+		$this->cdata = '';
+	}
+
+	private function clear() {
+		$this->wxr_version = '';
+
+		$this->cdata = '';
+		$this->data = [];
+		$this->sub_data = [];
+
+		$this->in_post = false;
+		$this->in_tag = false;
+		$this->in_sub_tag = false;
+
+		$this->authors = [];
+		$this->posts = [];
+		$this->term = [];
+		$this->category = [];
+		$this->tag = [];
+	}
+}

wp-content/plugins/elementor-3.2.5-bck4/core/utils/import-export/parsers/wxr-parser.php

@@ -0,0 +1,48 @@
+<?php
+namespace Elementor\Core\Utils\ImportExport\Parsers;
+
+if ( ! defined( 'ABSPATH' ) ) {
+	exit; // Exit if accessed directly.
+}
+
+/**
+ * WordPress eXtended RSS file parser implementations,
+ * Originally made by WordPress part of WordPress/Importer.
+ * https://plugins.trac.wordpress.org/browser/wordpress-importer/trunk/parsers/class-wxr-parser.php
+ *
+ * What was done:
+ * Reformat of the code.
+ * Changed text domain.
+ */
+
+/**
+ * WordPress Importer class for managing parsing of WXR files.
+ */
+class WXR_Parser {
+
+	public function parse( $file ) {
+		// Attempt to use proper XML parsers first.
+		if ( extension_loaded( 'simplexml' ) ) {
+			$parser = new WXR_Parser_SimpleXML();
+			$result = $parser->parse( $file );
+
+			// If SimpleXML succeeds or this is an invalid WXR file then return the results.
+			if ( ! is_wp_error( $result ) || 'SimpleXML_parse_error' != $result->get_error_code() ) {
+				return $result;
+			}
+		} elseif ( extension_loaded( 'xml' ) ) {
+			$parser = new WXR_Parser_XML();
+			$result = $parser->parse( $file );
+
+			// If XMLParser succeeds or this is an invalid WXR file then return the results.
+			if ( ! is_wp_error( $result ) || 'XML_parse_error' != $result->get_error_code() ) {
+				return $result;
+			}
+		}
+
+		// Use regular expressions if nothing else available or this is bad XML.
+		$parser = new WXR_Parser_Regex();
+
+		return $parser->parse( $file );
+	}
+}

wp-content/plugins/elementor-3.2.5-bck4/core/utils/import-export/wp-exporter.php

@@ -0,0 +1,749 @@
+<?php
+namespace Elementor\Core\Utils\ImportExport;
+
+if ( ! defined( 'ABSPATH' ) ) {
+	exit; // Exit if accessed directly.
+}
+
+/*
+ * Originally made by WordPress.
+ *
+ * What changed:
+ *  Remove echos.
+ *  Fix indents.
+ *  Add methods
+ *      indent.
+ *      wxr_categories_list.
+ *      wxr_tags_list.
+ *      wxr_terms_list.
+ *      wxr_posts_list.
+ */
+class WP_Exporter {
+	const WXR_VERSION = '1.2';
+
+	private static $default_args = [
+		'content' => 'all',
+		'author' => false,
+		'category' => false,
+		'start_date' => false,
+		'end_date' => false,
+		'status' => false,
+		'offset' => 0,
+		'limit' => -1,
+		'meta_key' => '', // If specified `meta_key` then will include all post(s) that have this meta_key.
+	];
+
+	/**
+	 * @var array
+	 */
+	private $args;
+
+	/**
+	 * @var \wpdb
+	 */
+	private $wpdb;
+
+	/**
+	 * Run export, by requested args.
+	 * Returns XML with exported data.
+	 *
+	 * @return string
+	 */
+	public function run() {
+		if ( 'all' !== $this->args['content'] && post_type_exists( $this->args['content'] ) ) {
+			$ptype = get_post_type_object( $this->args['content'] );
+			if ( ! $ptype->can_export ) {
+				$this->args['content'] = 'post';
+			}
+
+			$where = $this->wpdb->prepare( "{$this->wpdb->posts}.post_type = %s", $this->args['content'] );// phpcs:ignore
+		} else {
+			$post_types = get_post_types( [ 'can_export' => true ] );
+			$esses = array_fill( 0, count( $post_types ), '%s' );
+
+			$where = $this->wpdb->prepare( "{$this->wpdb->posts}.post_type IN (" . implode( ',', $esses ) . ')', $post_types );// phpcs:ignore
+		}
+
+		if ( $this->args['status'] && ( 'post' === $this->args['content'] || 'page' === $this->args['content'] ) ) {
+			$where .= $this->wpdb->prepare( " AND {$this->wpdb->posts}.post_status = %s", $this->args['status'] );// phpcs:ignore
+		} else {
+			$where .= " AND {$this->wpdb->posts}.post_status != 'auto-draft'";
+		}
+
+		$join = '';
+		if ( $this->args['category'] && 'post' === $this->args['content'] ) {
+			$term = term_exists( $this->args['category'], 'category' );
+			if ( $term ) {
+				$join = "INNER JOIN {$this->wpdb->term_relationships} ON ({$this->wpdb->posts}.ID = {$this->wpdb->term_relationships}.object_id)";
+				$where .= $this->wpdb->prepare( " AND {$this->wpdb->term_relationships}.term_taxonomy_id = %d", $term['term_taxonomy_id'] );// phpcs:ignore
+			}
+		}
+
+		if ( in_array( $this->args['content'], [ 'post', 'page', 'attachment' ], true ) ) {
+			if ( $this->args['author'] ) {
+				$where .= $this->wpdb->prepare( " AND {$this->wpdb->posts}.post_author = %d", $this->args['author'] );// phpcs:ignore
+			}
+
+			if ( $this->args['start_date'] ) {
+				$where .= $this->wpdb->prepare( " AND {$this->wpdb->posts}.post_date >= %s", gmdate( 'Y-m-d', strtotime( $this->args['start_date'] ) ) );// phpcs:ignore
+			}
+
+			if ( $this->args['end_date'] ) {
+				$where .= $this->wpdb->prepare( " AND {$this->wpdb->posts}.post_date < %s", gmdate( 'Y-m-d', strtotime( '+1 month', strtotime( $this->args['end_date'] ) ) ) );// phpcs:ignore
+			}
+		}
+
+		$limit = '';
+		if ( -1 !== (int) $this->args['limit'] ) {
+			$limit = 'LIMIT ' . (int) $this->args['limit'] . ' OFFSET ' . (int) $this->args['offset'];
+		}
+
+		if ( ! empty( $this->args['meta_key'] ) ) {
+			if ( $join ) {
+				$join .= ' ';
+			}
+
+			if ( $where ) {
+				$where .= ' AND ';
+			}
+
+			$join .= "LEFT JOIN {$this->wpdb->postmeta} ON ({$this->wpdb->posts}.ID = {$this->wpdb->postmeta}.post_id)";
+			$where .= $this->wpdb->prepare( "{$this->wpdb->postmeta}.meta_key = %s", $this->args['meta_key'] );// phpcs:ignore
+		}
+
+		// Grab a snapshot of post IDs, just in case it changes during the export.
+		$post_ids = $this->wpdb->get_col( "SELECT ID FROM {$this->wpdb->posts} $join WHERE $where $limit" );// phpcs:ignore
+
+		/*
+		 * Get the requested terms ready, empty unless posts filtered by category
+		 * or all content.
+		 */
+		$cats = [];
+		$tags = [];
+		$terms = [];
+		if ( isset( $term ) && $term ) {
+			$cat = get_term( $term['term_id'], 'category' );
+			$cats = [ $cat->term_id => $cat ];
+			unset( $term, $cat );
+		} elseif ( 'all' === $this->args['content'] ) {
+			$categories = (array) get_categories( [ 'get' => 'all' ] );
+			$tags = (array) get_tags( array( 'get' => 'all' ) );
+
+			$custom_taxonomies = get_taxonomies( [ '_builtin' => false ] );
+			$custom_terms = (array) get_terms( [
+				'taxonomy' => $custom_taxonomies,
+				'get' => 'all',
+			] );
+
+			// Put categories in order with no child going before its parent.
+			while ( $cat = array_shift( $categories ) ) {
+				if ( 0 == $cat->parent || isset( $cats[ $cat->parent ] ) ) {
+					$cats[ $cat->term_id ] = $cat;
+				} else {
+					$categories[] = $cat;
+				}
+			}
+
+			// Put terms in order with no child going before its parent.
+			while ( $t = array_shift( $custom_terms ) ) {
+				if ( 0 == $t->parent || isset( $terms[ $t->parent ] ) ) {
+					$terms[ $t->term_id ] = $t;
+				} else {
+					$custom_terms[] = $t;
+				}
+			}
+
+			unset( $categories, $custom_taxonomies, $custom_terms );
+		}
+
+		return $this->get_xml_export( $post_ids, $cats, $tags, $terms );
+	}
+
+	/**
+	 * Return tabulation characters, by `$columns`.
+	 *
+	 * @param int $columns
+	 *
+	 * @return string
+	 */
+	private function indent( $columns = 1 ) {
+		$output = '';
+
+		for ( $i = 0; $i < $columns; $i++ ) {
+			$output .= "\t";
+		}
+
+		return (string) $output;
+	}
+
+	/**
+	 * Return wrapped given string in XML CDATA tag.
+	 *
+	 * @param string $str String to wrap in XML CDATA tag.
+	 *
+	 * @return string
+	 */
+	private function wxr_cdata( $str ) {
+		$str = (string) $str;
+
+		if ( ! seems_utf8( $str ) ) {
+			$str = utf8_encode( $str );
+		}
+
+		$str = '<![CDATA[' . str_replace( ']]>', ']]]]><![CDATA[>', $str ) . ']]>';
+
+		return $str;
+	}
+
+	/**
+	 * Return the URL of the site.
+	 *
+	 * @return string Site URL.
+	 */
+	private function wxr_site_url() {
+		if ( is_multisite() ) {
+			// Multisite: the base URL.
+			return network_home_url();
+		} else {
+			// WordPress (single site): the blog URL.
+			return get_bloginfo_rss( 'url' );
+		}
+	}
+
+	/**
+	 * Return a cat_name XML tag from a given category object.
+	 *
+	 * @param \WP_Term $category Category Object
+	 *
+	 * @return string
+	 */
+	private function wxr_cat_name( $category ) {
+		if ( empty( $category->name ) ) {
+			return '';
+		}
+
+		return $this->indent( 3 ) . '<wp:cat_name>' . $this->wxr_cdata( $category->name ) . '</wp:cat_name>' . PHP_EOL;
+	}
+
+	/**
+	 * Return a category_description XML tag from a given category object.
+	 *
+	 * @param \WP_Term $category Category Object
+	 *
+	 * @return string
+	 */
+	private function wxr_category_description( $category ) {
+		if ( empty( $category->description ) ) {
+			return '';
+		}
+
+		return $this->indent( 3 ) . '<wp:category_description>' . $this->wxr_cdata( $category->description ) . "</wp:category_description>\n";
+	}
+
+	/**
+	 * Return a tag_name XML tag from a given tag object.
+	 *
+	 * @param \WP_Term $tag Tag Object
+	 *
+	 * @return string
+	 */
+	private function wxr_tag_name( $tag ) {
+		if ( empty( $tag->name ) ) {
+			return '';
+		}
+
+		return $this->indent( 3 ) . '<wp:tag_name>' . $this->wxr_cdata( $tag->name ) . '</wp:tag_name>' . PHP_EOL;
+	}
+
+	/**
+	 * Return a tag_description XML tag from a given tag object.
+	 *
+	 * @param \WP_Term $tag Tag Object
+	 *
+	 * @return string
+	 */
+	private function wxr_tag_description( $tag ) {
+		if ( empty( $tag->description ) ) {
+			return '';
+		}
+
+		return $this->indent( 3 ) . '<wp:tag_description>' . $this->wxr_cdata( $tag->description ) . '</wp:tag_description>' . PHP_EOL;
+	}
+
+	/**
+	 * Return a term_name XML tag from a given term object.
+	 *
+	 * @param \WP_Term $term Term Object
+	 *
+	 * @return string
+	 */
+	private function wxr_term_name( $term ) {
+		if ( empty( $term->name ) ) {
+			return '';
+		}
+
+		return $this->indent( 3 ) . '<wp:term_name>' . $this->wxr_cdata( $term->name ) . '</wp:term_name>' . PHP_EOL;
+	}
+
+	/**
+	 * Return a term_description XML tag from a given term object.
+	 *
+	 * @param \WP_Term $term Term Object
+	 *
+	 * @return string
+	 */
+	private function wxr_term_description( $term ) {
+		if ( empty( $term->description ) ) {
+			return '';
+		}
+
+		return $this->indent( 3 ) . '<wp:term_description>' . $this->wxr_cdata( $term->description ) . '</wp:term_description>' . PHP_EOL;
+	}
+
+	/**
+	 * Return term meta XML tags for a given term object.
+	 *
+	 * @param \WP_Term $term Term object.
+	 *
+	 * @return string
+	 */
+	private function wxr_term_meta( $term ) {
+		$result = '';
+		$termmeta = $this->wpdb->get_results( $this->wpdb->prepare( "SELECT * FROM {$this->wpdb->termmeta} WHERE term_id = %d", $term->term_id ) );// phpcs:ignore
+
+		foreach ( $termmeta as $meta ) {
+			/**
+			 * Filters whether to selectively skip term meta used for WXR exports.
+			 *
+			 * Returning a truthy value from the filter will skip the current meta
+			 * object from being exported.
+			 *
+			 * @since 4.6.0
+			 *
+			 * @param bool   $skip     Whether to skip the current piece of term meta. Default false.
+			 * @param string $meta_key Current meta key.
+			 * @param object $meta     Current meta object.
+			 */
+			if ( ! apply_filters( 'wxr_export_skip_termmeta', false, $meta->meta_key, $meta ) ) {
+				$result .= sprintf( $this->indent( 3 ) . "<wp:termmeta>\n\t\t\t<wp:meta_key>%s</wp:meta_key>\n\t\t\t<wp:meta_value>%s</wp:meta_value>\n\t\t</wp:termmeta>\n", wxr_cdata( $meta->meta_key ), wxr_cdata( $meta->meta_value ) );
+			}
+		}
+
+		return $result;
+	}
+
+	/**
+	 * Return list of authors with posts.
+	 *
+	 * @param int[] $post_ids Optional. Array of post IDs to filter the query by.
+	 *
+	 * @return string
+	 */
+	private function wxr_authors_list( array $post_ids = null ) {
+		$result = '';
+
+		if ( ! empty( $post_ids ) ) {
+			$post_ids = array_map( 'absint', $post_ids );
+			$and = 'AND ID IN ( ' . implode( ', ', $post_ids ) . ')';
+		} else {
+			$and = '';
+		}
+
+		$authors = [];
+		$results = $this->wpdb->get_results( "SELECT DISTINCT post_author FROM {$this->wpdb->posts} WHERE post_status != 'auto-draft' $and" );// phpcs:ignore
+		foreach ( (array) $results as $r ) {
+			$authors[] = get_userdata( $r->post_author );
+		}
+
+		$authors = array_filter( $authors );
+
+		foreach ( $authors as $author ) {
+			$result .= $this->indent( 2 ) . '<wp:author>' . PHP_EOL;
+
+			$result .= $this->indent( 3 ) . '<wp:author_id>' . (int) $author->ID . '</wp:author_id>' . PHP_EOL;
+			$result .= $this->indent( 3 ) . '<wp:author_login>' . $this->wxr_cdata( $author->user_login ) . '</wp:author_login>' . PHP_EOL;
+			$result .= $this->indent( 3 ) . '<wp:author_email>' . $this->wxr_cdata( $author->user_email ) . '</wp:author_email>' . PHP_EOL;
+			$result .= $this->indent( 3 ) . '<wp:author_display_name>' . $this->wxr_cdata( $author->display_name ) . '</wp:author_display_name>' . PHP_EOL;
+			$result .= $this->indent( 3 ) . '<wp:author_first_name>' . $this->wxr_cdata( $author->first_name ) . '</wp:author_first_name>' . PHP_EOL;
+			$result .= $this->indent( 3 ) . '<wp:author_last_name>' . $this->wxr_cdata( $author->last_name ) . '</wp:author_last_name>' . PHP_EOL;
+
+			$result .= $this->indent( 2 ) . '</wp:author>' . PHP_EOL;
+		}
+
+		return $result;
+	}
+
+	/**
+	 * Return list of categories.
+	 *
+	 * @param array $cats
+	 *
+	 * @return string
+	 */
+	private function wxr_categories_list( array $cats ) {
+		$result = '';
+
+		foreach ( $cats as $c ) {
+			$result .= $this->indent( 2 ) . '<wp:category>' . PHP_EOL;
+
+			$result .= $this->indent( 3 ) . '<wp:term_id>' . (int) $c->term_id . '</wp:term_id>' . PHP_EOL;
+			$result .= $this->indent( 3 ) . '<wp:category_nicename>' . $this->wxr_cdata( $c->slug ) . '</wp:category_nicename>' . PHP_EOL;
+			$result .= $this->indent( 3 ) . '<wp:category_parent>' . $this->wxr_cdata( $c->parent ? $cats[ $c->parent ]->slug : '' ) . '</wp:category_parent>' . PHP_EOL;
+			$result .= $this->wxr_cat_name( $c ) .
+						$this->wxr_category_description( $c ) .
+						$this->wxr_term_meta( $c );
+
+			$result .= $this->indent( 2 ) . '</wp:category>' . PHP_EOL;
+		}
+
+		return $result;
+	}
+
+	/**
+	 * Return list of tags.
+	 *
+	 * @param array $tags
+	 *
+	 * @return string
+	 */
+	private function wxr_tags_list( array $tags ) {
+		$result = '';
+
+		foreach ( $tags as $t ) {
+			$result .= $this->indent( 2 ) . '<wp:tag>' . PHP_EOL;
+
+			$result .= $this->indent( 3 ) . '<wp:term_id>' . (int) $t->term_id . '</wp:term_id>' . PHP_EOL;
+			$result .= $this->indent( 3 ) . '<wp:tag_slug>' . $this->wxr_cdata( $t->slug ) . '</wp:tag_slug>' . PHP_EOL;
+			$result .= $this->wxr_tag_name( $t ) .
+						$this->wxr_tag_description( $t ) .
+						$this->wxr_term_meta( $t );
+
+			$result .= $this->indent( 2 ) . '</wp:tag>' . PHP_EOL;
+		}
+
+		return $result;
+	}
+
+	/**
+	 * Return list of terms.
+	 *
+	 * @param array $terms
+	 *
+	 * @return string
+	 */
+	private function wxr_terms_list( array $terms ) {
+		$result = '';
+
+		foreach ( $terms as $t ) {
+			$result .= $this->indent( 2 ) . '<wp:term>' . PHP_EOL;
+
+			$result .= $this->indent( 3 ) . '<wp:term_taxonomy>' . $this->wxr_cdata( $t->taxonomy ) . '</wp:term_taxonomy>' . PHP_EOL;
+			$result .= $this->indent( 3 ) . '<wp:term_slug>' . $this->wxr_cdata( $t->slug ) . '</wp:term_slug>' . PHP_EOL;
+			$result .= $this->indent( 3 ) . '<wp:term_parent>' . $this->wxr_cdata( $t->parent ? $terms[ $t->parent ]->slug : '' ) . '</wp:term_parent>' . PHP_EOL;
+			$result .= $this->wxr_term_name( $t ) .
+						$this->wxr_term_description( $t ) .
+						$this->wxr_term_meta( $t );
+
+			$result .= $this->indent( 2 ) . '</wp:term>' . PHP_EOL;
+		}
+
+		return $result;
+	}
+
+	/**
+	 * Return list of posts, by requested `$post_ids`.
+	 *
+	 * @param array $post_ids
+	 *
+	 * @return string
+	 */
+	private function wxr_posts_list( array $post_ids ) {
+		$result = '';
+
+		if ( $post_ids ) {
+			global $wp_query;
+
+			// Fake being in the loop.
+			$wp_query->in_the_loop = true;
+
+			// Fetch 20 posts at a time rather than loading the entire table into memory.
+			while ( $next_posts = array_splice( $post_ids, 0, 20 ) ) {
+				$where = 'WHERE ID IN (' . implode( ',', $next_posts ) . ')';
+				$posts = $this->wpdb->get_results( "SELECT * FROM {$this->wpdb->posts} $where" );// phpcs:ignore
+
+				// Begin Loop.
+				foreach ( $posts as $post ) {
+					setup_postdata( $post );
+
+					$title = apply_filters( 'the_title_rss', $post->post_title );
+
+					/**
+					 * Filters the post content used for WXR exports.
+					 *
+					 * @since 2.5.0
+					 *
+					 * @param string $post_content Content of the current post.
+					 */
+					$content = $this->wxr_cdata( apply_filters( 'the_content_export', $post->post_content ) );
+
+					/**
+					 * Filters the post excerpt used for WXR exports.
+					 *
+					 * @since 2.6.0
+					 *
+					 * @param string $post_excerpt Excerpt for the current post.
+					 */
+					$excerpt = $this->wxr_cdata( apply_filters( 'the_excerpt_export', $post->post_excerpt ) );
+
+					$result .= $this->indent( 2 ) . '<item>' . PHP_EOL;
+
+					$result .= $this->indent( 3 ) . '<title>' . $title . '</title>' . PHP_EOL;
+					$result .= $this->indent( 3 ) . '<link>' . esc_url( get_permalink() ) . '</link>' . PHP_EOL;
+					$result .= $this->indent( 3 ) . '<pubDate>' . mysql2date( 'D, d M Y H:i:s +0000', get_post_time( 'Y-m-d H:i:s', true ), false ) . '</pubDate>' . PHP_EOL;
+					$result .= $this->indent( 3 ) . '<dc:creator>' . $this->wxr_cdata( get_the_author_meta( 'login' ) ) . '</dc:creator>' . PHP_EOL;
+					$result .= $this->indent( 3 ) . '<guid isPermaLink="false">' . $this->wxr_cdata( get_the_author_meta( 'login' ) ) . '</guid>' . PHP_EOL;
+					$result .= $this->indent( 3 ) . '<description></description>' . PHP_EOL;
+					$result .= $this->indent( 3 ) . '<content:encoded>' . $content . '</content:encoded>' . PHP_EOL;
+					$result .= $this->indent( 3 ) . '<excerpt:encoded>' . $excerpt . '</excerpt:encoded>' . PHP_EOL;
+					$result .= $this->indent( 3 ) . '<wp:post_id>' . (int) $post->ID . '</wp:post_id>' . PHP_EOL;
+					$result .= $this->indent( 3 ) . '<wp:post_date>' . $this->wxr_cdata( $post->post_date ) . '</wp:post_date>' . PHP_EOL;
+					$result .= $this->indent( 3 ) . '<wp:post_date_gmt>' . $this->wxr_cdata( $post->post_date_gmt ) . '</wp:post_date_gmt>' . PHP_EOL;
+					$result .= $this->indent( 3 ) . '<wp:comment_status>' . $this->wxr_cdata( $post->comment_status ) . '</wp:comment_status>' . PHP_EOL;
+					$result .= $this->indent( 3 ) . '<wp:ping_status>' . $this->wxr_cdata( $post->ping_status ) . '</wp:ping_status>' . PHP_EOL;
+					$result .= $this->indent( 3 ) . '<wp:post_name>' . $this->wxr_cdata( $post->post_name ) . '</wp:post_name>' . PHP_EOL;
+					$result .= $this->indent( 3 ) . '<wp:status>' . $this->wxr_cdata( $post->post_status ) . '</wp:status>' . PHP_EOL;
+					$result .= $this->indent( 3 ) . '<wp:post_parent>' . $this->wxr_cdata( $post->post_parent ) . '</wp:post_parent>' . PHP_EOL;
+					$result .= $this->indent( 3 ) . '<wp:menu_order>' . (int) $post->menu_order . '</wp:menu_order>' . PHP_EOL;
+					$result .= $this->indent( 3 ) . '<wp:post_type>' . $this->wxr_cdata( $post->post_type ) . '</wp:post_type>' . PHP_EOL;
+					$result .= $this->indent( 3 ) . '<wp:post_password>' . $this->wxr_cdata( $post->post_password ) . '</wp:post_password>' . PHP_EOL;
+					$result .= $this->indent( 3 ) . '<wp:is_sticky>' . ( is_sticky( $post->ID ) ? 1 : 0 ) . '</wp:is_sticky>' . PHP_EOL;
+
+					if ( 'attachment' === $post->post_type ) {
+						$result .= $this->indent( 3 ) . '<wp:attachment_url>' . $this->wxr_cdata( wp_get_attachment_url( $post->ID ) ) . '</wp:attachment_url>' . PHP_EOL;
+					}
+
+					$result .= $this->wxr_post_taxonomy( $post );
+
+					$postmeta = $this->wpdb->get_results( $this->wpdb->prepare( "SELECT * FROM {$this->wpdb->postmeta} WHERE post_id = %d", $post->ID ) );// phpcs:ignore
+					foreach ( $postmeta as $meta ) {
+						/**
+						 * Filters whether to selectively skip post meta used for WXR exports.
+						 *
+						 * Returning a truthy value from the filter will skip the current meta
+						 * object from being exported.
+						 *
+						 * @since 3.3.0
+						 *
+						 * @param bool   $skip     Whether to skip the current post meta. Default false.
+						 * @param string $meta_key Current meta key.
+						 * @param object $meta     Current meta object.
+						 */
+						if ( apply_filters( 'wxr_export_skip_postmeta', false, $meta->meta_key, $meta ) ) {
+							continue;
+						}
+
+						$result .= $this->indent( 3 ) . '<wp:postmeta>' . PHP_EOL;
+
+						$result .= $this->indent( 4 ) . '<wp:meta_key>' . $this->wxr_cdata( $meta->meta_key ) . '</wp:meta_key>' . PHP_EOL;
+						$result .= $this->indent( 4 ) . '<wp:meta_value>' . $this->wxr_cdata( $meta->meta_value ) . '</wp:meta_value>' . PHP_EOL;
+
+						$result .= $this->indent( 3 ) . '</wp:postmeta>' . PHP_EOL;
+					}
+
+					$_comments = $this->wpdb->get_results( $this->wpdb->prepare( "SELECT * FROM {$this->wpdb->comments} WHERE comment_post_ID = %d AND comment_approved <> 'spam'", $post->ID ) );// phpcs:ignore
+					$comments  = array_map( 'get_comment', $_comments );
+					foreach ( $comments as $c ) {
+
+						$result .= $result .= $this->indent( 3 ) . '<wp:comment>' . PHP_EOL;
+
+						$result .= $this->indent( 4 ) . '<wp:comment_id>' . (int) $c->comment_ID . '</wp:comment_id>' . PHP_EOL;
+						$result .= $this->indent( 4 ) . '<wp:comment_author>' . $this->wxr_cdata( $c->comment_author ) . '</wp:comment_author>' . PHP_EOL;
+						$result .= $this->indent( 4 ) . '<wp:comment_author_email>' . $this->wxr_cdata( $c->comment_author_email ) . '</wp:comment_author_email>' . PHP_EOL;
+						$result .= $this->indent( 4 ) . '<wp:comment_author_url>' . $this->wxr_cdata( $c->comment_author_url ) . '</wp:comment_author_url>' . PHP_EOL;
+						$result .= $this->indent( 4 ) . '<wp:comment_author_IP>' . $this->wxr_cdata( $c->comment_author_IP ) . '</wp:comment_author_IP>' . PHP_EOL;
+						$result .= $this->indent( 4 ) . '<wp:comment_date>' . $this->wxr_cdata( $c->comment_date ) . '</wp:comment_date>' . PHP_EOL;
+						$result .= $this->indent( 4 ) . '<wp:comment_date_gmt>' . $this->wxr_cdata( $c->comment_date_gmt ) . '</wp:comment_date_gmt>' . PHP_EOL;
+						$result .= $this->indent( 4 ) . '<wp:comment_content>' . $this->wxr_cdata( $c->comment_content ) . '</wp:comment_content>' . PHP_EOL;
+						$result .= $this->indent( 4 ) . '<wp:comment_approved>' . $this->wxr_cdata( $c->comment_approved ) . '</wp:comment_approved>' . PHP_EOL;
+						$result .= $this->indent( 4 ) . '<wp:comment_type>' . $this->wxr_cdata( $c->comment_type ) . '</wp:comment_type>' . PHP_EOL;
+						$result .= $this->indent( 4 ) . '<wp:comment_parent>' . $this->wxr_cdata( $c->comment_parent ) . '</wp:comment_parent>' . PHP_EOL;
+						$result .= $this->indent( 4 ) . '<wp:comment_user_id>' . (int) $c->user_id . '</wp:comment_user_id>' . PHP_EOL;
+
+						$c_meta = $this->wpdb->get_results( $this->wpdb->prepare( "SELECT * FROM {$this->wpdb->commentmeta} WHERE comment_id = %d", $c->comment_ID ) );// phpcs:ignore
+						foreach ( $c_meta as $meta ) {
+							/**
+							 * Filters whether to selectively skip comment meta used for WXR exports.
+							 *
+							 * Returning a truthy value from the filter will skip the current meta
+							 * object from being exported.
+							 *
+							 * @since 4.0.0
+							 *
+							 * @param bool   $skip     Whether to skip the current comment meta. Default false.
+							 * @param string $meta_key Current meta key.
+							 * @param object $meta     Current meta object.
+							 */
+							if ( apply_filters( 'wxr_export_skip_commentmeta', false, $meta->meta_key, $meta ) ) {
+								continue;
+							}
+
+							$result .= $result .= $this->indent( 4 ) . '<wp:commentmeta>' . PHP_EOL;
+
+							$result .= $this->indent( 5 ) . '<wp:meta_key>' . $this->wxr_cdata( $meta->meta_key ) . '</wp:meta_key>' . PHP_EOL;
+							$result .= $this->indent( 5 ) . '<wp:meta_value>' . $this->wxr_cdata( $meta->meta_key ) . '</wp:meta_value>' . PHP_EOL;
+
+							$result .= $result .= $this->indent( 4 ) . '</wp:commentmeta>' . PHP_EOL;
+						}
+
+						$result .= $result .= $this->indent( 3 ) . '</wp:comment>' . PHP_EOL;
+					}
+
+					$result .= $this->indent( 2 ) . '</item>' . PHP_EOL;
+				}
+			}
+		}
+
+		return $result;
+	}
+
+	/**
+	 * Return all navigation menu terms
+	 *
+	 * @return string
+	 */
+	private function wxr_nav_menu_terms() {
+		$nav_menus = wp_get_nav_menus();
+		if ( empty( $nav_menus ) || ! is_array( $nav_menus ) ) {
+			return '';
+		}
+
+		$result = '';
+
+		foreach ( $nav_menus as $menu ) {
+			$result .= $this->indent( 2 ) . '<wp:term>' . PHP_EOL;
+
+			$result .= $this->indent( 3 ) . '<wp:term_id>' . (int) $menu->term_id . '</wp:term_id>' . PHP_EOL;
+			$result .= $this->indent( 3 ) . '<wp:term_taxonomy>nav_menu</wp:term_taxonomy>' . PHP_EOL;
+			$result .= $this->indent( 3 ) . '<wp:term_slug>' . $this->wxr_cdata( $menu->slug ) . '</wp:term_slug>' . PHP_EOL;
+			$result .= wxr_term_name( $menu );
+
+			$result .= $this->indent( 2 ) . '</wp:term>' . PHP_EOL;
+		}
+
+		return $result;
+	}
+
+	/**
+	 * Return list of taxonomy terms, in XML tag format, associated with a post
+	 *
+	 * @param \WP_Post $post
+	 *
+	 * @return string
+	 */
+	private function wxr_post_taxonomy( $post ) {
+		$result = '';
+
+		$taxonomies = get_object_taxonomies( $post->post_type );
+
+		if ( empty( $taxonomies ) ) {
+			return $result;
+		}
+
+		$terms = wp_get_object_terms( $post->ID, $taxonomies );
+
+		foreach ( (array) $terms as $term ) {
+			$result .= $this->indent( 3 ) . "<category domain=\"{$term->taxonomy}\" nicename=\"{$term->slug}\">" . $this->wxr_cdata( $term->name ) . '</category>' . PHP_EOL;
+		}
+
+		return $result;
+	}
+
+	/**
+	 * Get's the XML export.
+	 *
+	 * @param $post_ids
+	 * @param $cats
+	 * @param $tags
+	 * @param $terms
+	 *
+	 * @return string
+	 */
+	private function get_xml_export( array $post_ids, array $cats, array $tags, array $terms ) {
+		$charset = get_bloginfo( 'charset' );
+		$generator = get_the_generator( 'export' );
+		$wxr_version = self::WXR_VERSION;
+		$wxr_site_url = $this->wxr_site_url();
+		$rss_info_name = get_bloginfo_rss( 'name' );
+		$rss_info_url = get_bloginfo_rss( 'url' );
+		$rss_info_description = get_bloginfo_rss( 'description' );
+		$rss_info_language = get_bloginfo_rss( 'language' );
+		$pub_date = gmdate( 'D, d M Y H:i:s +0000' );
+
+		$dynamic = $this->wxr_authors_list( $post_ids ) .
+					$this->wxr_categories_list( $cats ) .
+					$this->wxr_tags_list( $tags ) .
+					$this->wxr_terms_list( $terms );
+
+		ob_start();
+		/** This action is documented in wp-includes/feed-rss2.php */
+		do_action( 'rss2_head' );
+		$rss2_head = ob_get_clean();
+
+		$dynamic .= $rss2_head;
+
+		if ( 'all' === $this->args['content'] ) {
+			$dynamic .= $this->wxr_nav_menu_terms();
+		}
+
+		$dynamic .= $this->wxr_posts_list( $post_ids );
+
+		$result = <<<EOT
+<?xml version="1.0" encoding="$charset" ?>
+<!-- This is a WordPress eXtended RSS file generated by WordPress as an export of your site. -->
+<!-- It contains information about your site's posts, pages, comments, categories, and other content. -->
+<!-- You may use this file to transfer that content from one site to another. -->
+<!-- This file is not intended to serve as a complete backup of your site. -->
+
+<!-- To import this information into a WordPress site follow these steps: -->
+<!-- 1. Log in to that site as an administrator. -->
+<!-- 2. Go to Tools: Import in the WordPress admin panel. -->
+<!-- 3. Install the "WordPress" importer from the list. -->
+<!-- 4. Activate & Run Importer. -->
+<!-- 5. Upload this file using the form provided on that page. -->
+<!-- 6. You will first be asked to map the authors in this export file to users -->
+<!--    on the site. For each author, you may choose to map to an -->
+<!--    existing user on the site or to create a new user. -->
+<!-- 7. WordPress will then import each of the posts, pages, comments, categories, etc. -->
+<!--    contained in this file into your site. -->
+$generator
+<rss version="2.0"
+	xmlns:excerpt="http://wordpress.org/export/$wxr_version/excerpt/"
+	xmlns:content="http://purl.org/rss/1.0/modules/content/"
+	xmlns:wfw="http://wellformedweb.org/CommentAPI/"
+	xmlns:dc="http://purl.org/dc/elements/1.1/"
+	xmlns:wp="http://wordpress.org/export/$wxr_version/"
+>
+	<channel>
+		<title>$rss_info_name</title>
+		<link>$rss_info_url</link>
+		<description>$rss_info_description</description>
+		<pubDate>$pub_date</pubDate>
+		<language>$rss_info_language</language>
+		<wp:wxr_version>$wxr_version</wp:wxr_version>
+		<wp:base_site_url>$wxr_site_url</wp:base_site_url>
+		<wp:base_blog_url>$rss_info_url</wp:base_blog_url>
+$dynamic
+	</channel>
+</rss>
+EOT;
+		return $result;
+	}
+
+	public function __construct( array $args = [] ) {
+		global $wpdb;
+
+		$this->args = wp_parse_args( $args, self::$default_args );
+
+		$this->wpdb = $wpdb;
+	}
+}

wp-content/plugins/elementor-3.2.5-bck4/core/utils/version.php

@@ -0,0 +1,184 @@
+<?php
+namespace Elementor\Core\Utils;
+
+if ( ! defined( 'ABSPATH' ) ) {
+	exit; // Exit if accessed directly.
+}
+
+class Version {
+	const PART_MAJOR_1 = 'major1';
+	const PART_MAJOR_2 = 'major2';
+	const PART_PATCH = 'patch';
+	const PART_STAGE = 'stage';
+
+	/**
+	 * First number of a version 0.x.x
+	 *
+	 * @var string
+	 */
+	public $major1;
+
+	/**
+	 * Second number of a version x.0.x
+	 *
+	 * @var string
+	 */
+	public $major2;
+
+	/**
+	 * Third number of a version x.x.0
+	 *
+	 * @var string
+	 */
+	public $patch;
+
+	/**
+	 * The stage of a version x.x.x-stage.
+	 * e.g: x.x.x-dev1, x.x.x-beta3, x.x.x-rc
+	 *
+	 * @var string|null
+	 */
+	public $stage;
+
+	/**
+	 * Version constructor.
+	 *
+	 * @param $major1
+	 * @param $major2
+	 * @param $patch
+	 * @param $stage
+	 */
+	public function __construct( $major1, $major2, $patch, $stage = null ) {
+		$this->major1 = $major1;
+		$this->major2 = $major2;
+		$this->patch  = $patch;
+		$this->stage  = $stage;
+	}
+
+	/**
+	 * Create Version instance.
+	 *
+	 * @param string $major1
+	 * @param string $major2
+	 * @param string $patch
+	 * @param null   $stage
+	 *
+	 * @return static
+	 */
+	public static function create( $major1 = '0', $major2 = '0', $patch = '0', $stage = null ) {
+		return new static( $major1, $major2, $patch, $stage );
+	}
+
+	/**
+	 * Checks if the current version string is valid.
+	 *
+	 * @param $version
+	 *
+	 * @return bool
+	 */
+	public static function is_valid_version( $version ) {
+		return ! ! preg_match( '/^(\d+\.)?(\d+\.)?(\*|\d+)(-.+)?$/', $version );
+	}
+
+	/**
+	 * Creates a Version instance from a string.
+	 *
+	 * @param      $version
+	 * @param bool $should_validate
+	 *
+	 * @return static
+	 * @throws \Exception
+	 */
+	public static function create_from_string( $version, $should_validate = true ) {
+		if ( $should_validate && ! static::is_valid_version( $version ) ) {
+			throw new \Exception( "{$version} is an invalid version." );
+		}
+
+		$parts = explode( '.', $version );
+		$patch_parts = [];
+
+		$major1 = '0';
+		$major2 = '0';
+		$patch = '0';
+		$stage = null;
+
+		if ( isset( $parts[0] ) ) {
+			$major1 = $parts[0];
+		}
+
+		if ( isset( $parts[1] ) ) {
+			$major2 = $parts[1];
+		}
+
+		if ( isset( $parts[2] ) ) {
+			$patch_parts = explode( '-', $parts[2] );
+
+			$patch = $patch_parts[0];
+		}
+
+		if ( isset( $patch_parts[1] ) ) {
+			$stage = $patch_parts[1];
+		}
+
+		return static::create( $major1, $major2, $patch, $stage );
+	}
+
+	/**
+	 * Compare the current version instance with another version.
+	 *
+	 * @param        $operator
+	 * @param        $version
+	 * @param string $part
+	 *
+	 * @return bool
+	 * @throws \Exception
+	 */
+	public function compare( $operator, $version, $part = self::PART_STAGE ) {
+		if ( ! ( $version instanceof Version ) ) {
+			if ( ! static::is_valid_version( $version ) ) {
+				$version = '0.0.0';
+			}
+
+			$version = static::create_from_string( $version, false );
+		}
+
+		$current_version = clone $this;
+		$compare_version = clone $version;
+
+		if ( in_array( $part, [ self::PART_PATCH, self::PART_MAJOR_2, self::PART_MAJOR_1 ], true ) ) {
+			$current_version->stage = null;
+			$compare_version->stage = null;
+		}
+
+		if ( in_array( $part, [ self::PART_MAJOR_2, self::PART_MAJOR_1 ], true ) ) {
+			$current_version->patch = '0';
+			$compare_version->patch = '0';
+		}
+
+		if ( self::PART_MAJOR_1 === $part ) {
+			$current_version->major2 = '0';
+			$compare_version->major2 = '0';
+		}
+
+		return version_compare(
+			$current_version,
+			$compare_version,
+			$operator
+		);
+	}
+
+	/**
+	 * Implode the version and return it as string.
+	 *
+	 * @return string
+	 */
+	public function __toString() {
+		$version = implode( '.', [ $this->major1, $this->major2, $this->patch ] );
+
+		if ( $this->stage ) {
+			$version .= '-' . $this->stage;
+		}
+
+		return $version;
+	}
+}