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

use Elementor\Core\Base\Base_Object;
use Elementor\Core\Common\Modules\Ajax\Module as Ajax;
use Elementor\Core\Files\File_Types\Base as File_Type_Base;
use Elementor\Core\Files\File_Types\Json;
use Elementor\Core\Files\File_Types\Svg;
use Elementor\Core\Files\File_Types\Zip;
use Elementor\Core\Files\Fonts\Google_Font;
use Elementor\Core\Utils\Exceptions;
use Elementor\Fonts;
use Elementor\User;

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

/**
 * Elementor uploads manager.
 *
 * Elementor uploads manager handler class is responsible for handling file uploads that are not done with WP Media.
 *
 * @since 3.3.0
 */
class Uploads_Manager extends Base_Object {

	const UNFILTERED_FILE_UPLOADS_KEY = &#039;elementor_unfiltered_files_upload&#039;;
	const INVALID_FILE_CONTENT = &#039;Invalid Content In File&#039;;
	const ELEMENTOR_UPLOAD_DIR = &#039;elementor&#039;;

	/**
	 * @var File_Type_Base[]
	 */
	private $file_type_handlers = [];

	private $allowed_file_extensions;

	/**
	 * @var bool
	 */
	private $is_elementor_upload = false;

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

	/**
	 * Register File Types
	 *
	 * To Add a new file type to Elementor, with its own handling logic, you need to add it to the $file_types array here.
	 *
	 * @since 3.3.0
	 * @access public
	 */
	public function register_file_types() {
		// All file types that have handlers should be included here.
		$file_types = [
			&#039;json&#039; =&gt; new Json(),
			&#039;zip&#039; =&gt; new Zip(),
			&#039;svg&#039; =&gt; new Svg(),
		];

		foreach ( $file_types as $file_type =&gt; $file_handler ) {
			$this-&gt;file_type_handlers[ $file_type ] = $file_handler;
		}
	}

	/**
	 * Extract and Validate Zip
	 *
	 * This method accepts a $file array (which minimally should include a &#039;tmp_name&#039;)
	 *
	 * @since 3.3.0
	 * @access public
	 *
	 * @param string $file_path
	 * @param array  $allowed_file_types
	 * @return array|\WP_Error
	 */
	public function extract_and_validate_zip( $file_path, $allowed_file_types = null ) {
		$result = [];

		/** @var Zip $zip_handler - File Type */
		$zip_handler = $this-&gt;file_type_handlers[&#039;zip&#039;];

		// Returns an array of file paths.
		$extracted = $zip_handler-&gt;extract( $file_path, $allowed_file_types );

		if ( is_wp_error( $extracted ) ) {
			return $extracted;
		}

		// If there are no extracted file names, no files passed the extraction validation.
		if ( empty( $extracted[&#039;files&#039;] ) ) {
			// TODO: Decide what to do if no files passed the extraction validation
			return new \WP_Error( &#039;file_error&#039;, self::INVALID_FILE_CONTENT );
		}

		$result[&#039;extraction_directory&#039;] = $extracted[&#039;extraction_directory&#039;];

		foreach ( $extracted[&#039;files&#039;] as $extracted_file_path ) {
			// Each file is an array with a &#039;name&#039; (file path) property.
			if ( ! is_wp_error( $this-&gt;validate_file( [ &#039;tmp_name&#039; =&gt; $extracted_file_path ] ) ) ) {
				$result[&#039;files&#039;][] = $extracted_file_path;
			}
		}

		return $result;
	}

	/**
	 * Handle Elementor Upload
	 *
	 * This method receives a $file array. If the received file is a Base64 string, the $file array should include a
	 * &#039;fileData&#039; property containing the string, which is decoded and has its contents stored in a temporary file.
	 * If the $file parameter passed is a standard $file array, the &#039;name&#039; and &#039;tmp_name&#039; properties are used for
	 * validation.
	 *
	 * The file goes through validation; if it passes validation, the file is returned. Otherwise, an error is returned.
	 *
	 * @since 3.3.0
	 * @access public
	 *
	 * @param array $data
	 * @param array $allowed_file_extensions Optional. an array of file types that are allowed to pass validation for each
	 * upload.
	 * @return array|\WP_Error
	 */
	public function handle_elementor_upload( array $data, $allowed_file_extensions = null ) {
		// If $file[&#039;fileData&#039;] is set, it signals that the passed file is a Base64 string that needs to be decoded and
		// saved to a temporary file.
		if ( isset( $data[&#039;fileData&#039;] ) ) {
			$data = $this-&gt;save_base64_to_tmp_file( $data, $allowed_file_extensions );
		}

		if ( is_wp_error( $data ) ) {
			return $data;
		}

		if ( ! isset( $data[&#039;fileData&#039;] ) ) {
			if ( empty( $data[&#039;tmp_name&#039;] ) ) {
				return new \WP_Error( &#039;file_error&#039;, esc_html__( &#039;Invalid temporary file path.&#039;, &#039;elementor&#039; ) );
			}

			// Path validation only applies to direct calls (e.g. import_template) where
			// tmp_name originates from user input. When is_elementor_upload is true, this
			// method is used as a WordPress filter (wp_handle_sideload_prefilter) and
			// tmp_name is set by WordPress core.
			if ( ! $this-&gt;is_elementor_upload &amp;&amp; ! $this-&gt;is_path_in_allowed_dir( $data[&#039;tmp_name&#039;] ) ) {
				return new \WP_Error( &#039;file_error&#039;, esc_html__( &#039;Invalid temporary file path.&#039;, &#039;elementor&#039; ) );
			}
		}

		$validation_result = $this-&gt;validate_file( $data, $allowed_file_extensions );

		if ( is_wp_error( $validation_result ) ) {
			if ( ! empty( $data[&#039;tmp_name&#039;] ) ) {
				$this-&gt;remove_file_or_dir( dirname( $data[&#039;tmp_name&#039;] ) );
			}

			return $validation_result;
		}

		return $data;
	}

	/**
	 * Is Unfiltered Uploads Enabled
	 *
	 * @since 3.5.0
	 * @access public
	 *
	 * @return bool
	 */
	final public static function are_unfiltered_uploads_enabled() {
		$enabled = (bool) get_option( self::UNFILTERED_FILE_UPLOADS_KEY )
			&amp;&amp; Svg::file_sanitizer_can_run()
			&amp;&amp; User::is_current_user_can_upload_json();

		/**
		 * Allow Unfiltered Files Upload.
		 *
		 * Determines whether to enable unfiltered file uploads.
		 *
		 * @since 3.0.0
		 *
		 * @param bool $enabled Whether upload is enabled or not.
		 */
		$enabled = apply_filters( &#039;elementor/files/allow_unfiltered_upload&#039;, $enabled );

		return $enabled;
	}

	/**
	 * Handle Elementor WP Media Upload
	 *
	 * Runs on the &#039;wp_handle_upload_prefilter&#039; filter.
	 *
	 * @since 3.2.0
	 * @access public
	 *
	 * @param $file
	 * @return mixed
	 */
	public function handle_elementor_wp_media_upload( $file ) {
		// If it isn&#039;t a file uploaded by Elementor, we do not intervene.
		if ( ! $this-&gt;is_elementor_wp_media_upload() ) {
			return $file;
		}

		$result = $this-&gt;validate_file( $file );

		if ( is_wp_error( $result ) ) {
			$file[&#039;error&#039;] = $result-&gt;get_error_message();
		}

		return $file;
	}

	/**
	 * Get File Type Handler
	 *
	 * Initialize the proper file type handler according to the file extension
	 * and assign it to the file type handlers array.
	 *
	 * @since 3.3.0
	 * @access public
	 *
	 * @param string|null $file_extension - file extension
	 * @return File_Type_Base[]|File_Type_Base
	 */
	public function get_file_type_handlers( $file_extension = null ) {
		return self::get_items( $this-&gt;file_type_handlers, $file_extension );
	}

	/**
	 * Check filetype and ext
	 *
	 * A workaround for upload validation which relies on a PHP extension (fileinfo)
	 * with inconsistent reporting behaviour.
	 * ref: https://core.trac.wordpress.org/ticket/39550
	 * ref: https://core.trac.wordpress.org/ticket/40175
	 *
	 * @since 3.5.0
	 * @access public
	 *
	 * @param $data
	 * @param $file
	 * @param $filename
	 * @param $mimes
	 *
	 * @return mixed
	 */
	public function check_filetype_and_ext( $data, $file, $filename, $mimes ) {
		if ( ! empty( $data[&#039;ext&#039;] ) &amp;&amp; ! empty( $data[&#039;type&#039;] ) ) {
			return $data;
		}

		$wp_file_type = wp_check_filetype( $filename, $mimes );

		$file_type_handlers = $this-&gt;get_file_type_handlers();

		if ( isset( $file_type_handlers[ $wp_file_type[&#039;ext&#039;] ] ) ) {
			$file_type_handler = $file_type_handlers[ $wp_file_type[&#039;ext&#039;] ];

			$data[&#039;ext&#039;] = $file_type_handler-&gt;get_file_extension();
			$data[&#039;type&#039;] = $file_type_handler-&gt;get_mime_type();
		}

		return $data;
	}

	/**
	 * Check if path is within the allowed Elementor uploads directory.
	 *
	 * Prevents path traversal and arbitrary directory deletion by ensuring the path
	 * resolves under wp-content/uploads/elementor/ or under the configured temp dir
	 * (elementor/files/temp-dir filter), so that cleanup works when temp dir is customized.
	 *
	 * @since 3.35.4
	 * @access private
	 *
	 * @param string $path
	 * @return bool
	 */
	private function is_path_in_allowed_dir( $path ) {
		if ( ! is_string( $path ) || &#039;&#039; === $path ) {
			return false;
		}

		$real_path = realpath( $path );

		if ( false === $real_path ) {
			$real_path = realpath( dirname( $path ) );
			if ( false === $real_path ) {
				return false;
			}
		}

		$wp_upload_dir = wp_upload_dir();
		$elementor_base = realpath( $wp_upload_dir[&#039;basedir&#039;] . DIRECTORY_SEPARATOR . self::ELEMENTOR_UPLOAD_DIR );

		if ( false !== $elementor_base ) {
			$allowed = $real_path === $elementor_base || 0 === strpos( $real_path, $elementor_base . DIRECTORY_SEPARATOR );
			if ( $allowed ) {
				return true;
			}
		}

		$temp_dir = realpath( $this-&gt;get_temp_dir() );
		if ( false !== $temp_dir ) {
			$temp_dir = rtrim( $temp_dir, DIRECTORY_SEPARATOR ) . DIRECTORY_SEPARATOR;
			return 0 === strpos( $real_path, $temp_dir );
		}

		return false;
	}

	/**
	 * Remove File Or Directory
	 *
	 * Directory is deleted recursively with all of its contents (subdirectories and files).
	 * Only paths under wp-content/uploads/elementor/ are allowed (security: prevents arbitrary directory deletion).
	 *
	 * @since 3.3.0
	 * @access public
	 *
	 * @param string $path
	 */
	public function remove_file_or_dir( $path ) {
		if ( ! $this-&gt;is_path_in_allowed_dir( $path ) ) {
			return;
		}

		if ( is_dir( $path ) ) {
			$this-&gt;remove_directory_with_files( $path );
		} elseif ( is_file( $path ) ) {
			unlink( $path );
		}
	}

	/**
	 * Create Temp File
	 *
	 * Create a random temporary file.
	 *
	 * @since 3.3.0
	 * @access public
	 *
	 * @param string $file_content
	 * @param string $file_name
	 * @return string|\WP_Error
	 */
	public function create_temp_file( $file_content, $file_name ) {
		$file_name = str_replace( &#039; &#039;, &#039;&#039;, sanitize_file_name( $file_name ) );

		if ( empty( $file_name ) ) {
			return new \WP_Error( &#039;invalid_file_name&#039;, esc_html__( &#039;Invalid file name.&#039;, &#039;elementor&#039; ) );
		}

		$temp_filename = $this-&gt;create_unique_dir() . $file_name;

		/**
		 * Temp File Path
		 *
		 * Allows modifying the full path of the temporary file.
		 *
		 * @since 3.7.0
		 *
		 * @param string full path to file
		 */
		$temp_filename = apply_filters( &#039;elementor/files/temp-file-path&#039;, $temp_filename );

		file_put_contents( $temp_filename, $file_content ); // phpcs:ignore

		return $temp_filename;
	}

	/**
	 * Get Temp Directory
	 *
	 * Get the temporary files directory path. If the directory does not exist, this method creates it.
	 *
	 * @since 3.3.0
	 * @access public
	 *
	 * @return string $temp_dir
	 */
	public function get_temp_dir() {
		if ( ! $this-&gt;temp_dir ) {
			$wp_upload_dir = wp_upload_dir();

			$temp_dir = implode( DIRECTORY_SEPARATOR, [ $wp_upload_dir[&#039;basedir&#039;], self::ELEMENTOR_UPLOAD_DIR, &#039;tmp&#039; ] ) . DIRECTORY_SEPARATOR;

			/**
			 * Temp File Path
			 *
			 * Allows modifying the full path of the temporary file.
			 *
			 * @since 3.7.0
			 *
			 * @param string temporary directory
			 */
			$this-&gt;temp_dir = apply_filters( &#039;elementor/files/temp-dir&#039;, $temp_dir );

			if ( ! is_dir( $this-&gt;temp_dir ) ) {
				wp_mkdir_p( $this-&gt;temp_dir );
			}
		}

		return $this-&gt;temp_dir;
	}

	/**
	 * Create Unique Temp Dir
	 *
	 * Create a unique temporary directory
	 *
	 * @since 3.3.0
	 * @access public
	 *
	 * @return string the new directory path
	 */
	public function create_unique_dir() {
		$unique_dir_path = $this-&gt;get_temp_dir() . uniqid() . DIRECTORY_SEPARATOR;

		wp_mkdir_p( $unique_dir_path );

		return $unique_dir_path;
	}

	/**
	 * Register Ajax Actions
	 *
	 * Runs on the &#039;elementor/ajax/register_actions&#039; hook. Receives the AJAX module as a parameter and registers
	 * callbacks for specified action IDs.
	 *
	 * @since 3.5.0
	 * @access public
	 *
	 * @param Ajax $ajax
	 */
	public function register_ajax_actions( Ajax $ajax ) {
		$ajax-&gt;register_ajax_action( &#039;enable_unfiltered_files_upload&#039;, [ $this, &#039;enable_unfiltered_files_upload&#039; ] );
		$ajax-&gt;register_ajax_action( &#039;enqueue_google_fonts&#039;, [ $this, &#039;ajax_enqueue_google_fonts&#039; ] );
	}

	/**
	 * Set Unfiltered Files Upload
	 *
	 * @since 3.5.0
	 * @access public
	 */
	public function enable_unfiltered_files_upload() {
		if ( ! current_user_can( &#039;manage_options&#039; ) ) {
			return;
		}

		update_option( self::UNFILTERED_FILE_UPLOADS_KEY, 1 );
	}

	public function ajax_enqueue_google_fonts( $data ): bool {
		if ( empty( $data[&#039;font_name&#039;] ) ) {
			return false;
		}

		$font_type = Fonts::get_font_type( $data[&#039;font_name&#039;] );

		if ( Fonts::GOOGLE !== $font_type ) {
			return false;
		}

		Google_Font::enqueue( $data[&#039;font_name&#039;] );

		return true;
	}

	/**
	 * Support Unfiltered File Uploads
	 *
	 * When uploading a file within Elementor, this method adds the registered
	 * file types to WordPress&#039; allowed mimes list. This will only happen if the user allowed unfiltered file uploads
	 * in Elementor&#039;s settings in the admin dashboard.
	 *
	 * @since 3.5.0
	 * @access public
	 *
	 * @param array $allowed_mimes
	 * @return array allowed mime types
	 */
	final public function support_unfiltered_elementor_file_uploads( $allowed_mimes ) {
		if ( $this-&gt;is_elementor_upload() &amp;&amp; $this-&gt;are_unfiltered_uploads_enabled() ) {
			foreach ( $this-&gt;file_type_handlers as $file_type_handler ) {
				$allowed_mimes[ $file_type_handler-&gt;get_file_extension() ] = $file_type_handler-&gt;get_mime_type();
			}
		}

		return $allowed_mimes;
	}

	/**
	 * Set Elementor Upload State
	 *
	 * @since 3.5.0
	 * @access public
	 *
	 * @param $state
	 */
	public function set_elementor_upload_state( $state ) {
		$this-&gt;is_elementor_upload = $state;
	}

	/**
	 * Is Elementor Upload
	 *
	 * This method checks if the current session includes a request to upload files made via Elementor.
	 *
	 * @since 3.5.0
	 * @access private
	 *
	 * @return bool
	 */
	private function is_elementor_upload() {
		return $this-&gt;is_elementor_upload || $this-&gt;is_elementor_media_upload() || $this-&gt;is_elementor_wp_media_upload();
	}

	/**
	 * Is Elementor Media Upload
	 *
	 * Checks whether the current request includes uploading files via Elementor which are not destined for the Media
	 * Library.
	 *
	 * @since 3.5.0
	 * @access public
	 *
	 * @return bool
	 */
	public function is_elementor_media_upload() {
		// Sometimes `uploadTypeCaller` passed as a GET parameter when using the WP Media Library REST API, where the
		// whole request body is occupied by the uploaded file.
		return isset( $_REQUEST[&#039;uploadTypeCaller&#039;] ) &amp;&amp; &#039;elementor-media-upload&#039; === $_REQUEST[&#039;uploadTypeCaller&#039;]; // phpcs:ignore
	}

	/**
	 * Is Elementor WP Media Upload
	 *
	 * Checks whether the current request is a request to upload files into the WP Media Library via Elementor.
	 *
	 * @since 3.3.0
	 * @access private
	 *
	 * @return bool
	 */
	private function is_elementor_wp_media_upload() {
		return isset( $_REQUEST[&#039;uploadTypeCaller&#039;] ) &amp;&amp; &#039;elementor-wp-media-upload&#039; === $_REQUEST[&#039;uploadTypeCaller&#039;]; // phpcs:ignore
	}

	/**
	 * Add File Extension To Allowed Extensions List
	 *
	 * @since 3.3.0
	 * @access private
	 *
	 * @param string $file_type
	 */
	private function add_file_extension_to_allowed_extensions_list( $file_type ) {
		$file_handler = $this-&gt;file_type_handlers[ $file_type ];

		$file_extension = $file_handler-&gt;get_file_extension();

		// Only add the file extension to the list if it doesn&#039;t already exist in it.
		if ( ! in_array( $file_extension, $this-&gt;allowed_file_extensions, true ) ) {
			$this-&gt;allowed_file_extensions[] = $file_extension;
		}
	}

	/**
	 * Save Base64 as File
	 *
	 * Saves a Base64 string as a .tmp file in Elementor&#039;s temporary files directory.
	 *
	 * @since 3.3.0
	 * @access private
	 *
	 * @param $file
	 * @param array|null $allowed_file_extensions
	 *
	 * @return array|\WP_Error
	 */
	private function save_base64_to_tmp_file( $file, $allowed_file_extensions = null ) {
		if ( empty( $file[&#039;fileName&#039;] ) || empty( $file[&#039;fileData&#039;] ) ) {
			return new \WP_Error( &#039;file_error&#039;, self::INVALID_FILE_CONTENT );
		}

		$file_extension = pathinfo( $file[&#039;fileName&#039;], PATHINFO_EXTENSION );
		$is_file_type_allowed = $this-&gt;is_file_type_allowed( $file_extension, $allowed_file_extensions );

		if ( is_wp_error( $is_file_type_allowed ) ) {
			return $is_file_type_allowed;
		}

		$file_content = base64_decode( $file[&#039;fileData&#039;] ); // phpcs:ignore

		// If the decode fails
		if ( ! $file_content ) {
			return new \WP_Error( &#039;file_error&#039;, self::INVALID_FILE_CONTENT );
		}

		$temp_filename = $this-&gt;create_temp_file( $file_content, $file[&#039;fileName&#039;] );

		if ( is_wp_error( $temp_filename ) ) {
			return $temp_filename;
		}

		return [
			// the original uploaded file name
			&#039;name&#039; =&gt; $file[&#039;fileName&#039;],
			// The path to the temporary file
			&#039;tmp_name&#039; =&gt; $temp_filename,
		];
	}

	/**
	 * Validate File
	 *
	 * @since 3.3.0
	 * @access private
	 *
	 * @param array $file
	 * @param array $file_extensions Optional
	 * @return bool|\WP_Error
	 */
	private function validate_file( array $file, $file_extensions = [] ) {
		$uploaded_file_name = isset( $file[&#039;name&#039;] ) ? $file[&#039;name&#039;] : $file[&#039;tmp_name&#039;];

		$file_extension = pathinfo( $uploaded_file_name, PATHINFO_EXTENSION );

		if ( ! $this-&gt;is_elementor_wp_media_upload() ) {
			$is_file_type_allowed = $this-&gt;is_file_type_allowed( $file_extension, $file_extensions );

			if ( is_wp_error( $is_file_type_allowed ) ) {
				return $is_file_type_allowed;
			}
		}

		$file_type_handler = $this-&gt;get_file_type_handlers( $file_extension );

		// If Elementor does not have a handler for this file type, don&#039;t block it.
		if ( ! $file_type_handler ) {
			return true;
		}

		// If there is a File Type Handler for the uploaded file, it means it is a non-standard file type. In this case,
		// we check if unfiltered file uploads are enabled or not before allowing it.
		if ( ! self::are_unfiltered_uploads_enabled() ) {
			$error = &#039;json&#039; === $file_extension
				? esc_html__( &#039;You do not have permission to upload JSON files.&#039;, &#039;elementor&#039; )
				: esc_html__( &#039;This file is not allowed for security reasons.&#039;, &#039;elementor&#039; );
			return new \WP_Error( Exceptions::FORBIDDEN, $error );
		}

		// Here is each file type handler&#039;s chance to run its own specific validations
		return $file_type_handler-&gt;validate_file( $file );
	}

	/**
	 * Is File Type Allowed
	 *
	 * Checks whether the passed file extension is allowed for upload.
	 *
	 * @since 3.5.0
	 * @access private
	 *
	 * @param $file_extension
	 * @param $filtered_file_extensions
	 * @return bool|\WP_Error
	 */
	private function is_file_type_allowed( $file_extension, $filtered_file_extensions ) {
		$allowed_file_extensions = $this-&gt;get_allowed_file_extensions();

		if ( $filtered_file_extensions ) {
			$allowed_file_extensions = array_intersect( $allowed_file_extensions, $filtered_file_extensions );
		}

		$is_allowed = false;

		// Check if the file type (extension) is in the allowed extensions list. If it is a non-standard file type (not
		// enabled by default in WordPress) and unfiltered file uploads are not enabled, it will not be in the allowed
		// file extensions list.
		foreach ( $allowed_file_extensions as $allowed_extension ) {
			if ( preg_match( &#039;/&#039; . $allowed_extension . &#039;/&#039;, $file_extension ) ) {
				$is_allowed = true;

				break;
			}
		}

		if ( ! $is_allowed ) {
			$is_allowed = new \WP_Error( Exceptions::FORBIDDEN, &#039;Uploading this file type is not allowed.&#039; );
		}

		/**
		 * Elementor File Type Allowed
		 *
		 * Allows setting file types
		 *
		 * @since 3.5.0
		 *
		 * @param bool|\WP_Error $is_allowed
		 */
		return apply_filters( &#039;elementor/files/allow-file-type/&#039; . $file_extension, $is_allowed );
	}

	/**
	 * Remove Directory with Files
	 *
	 * @since 3.3.0
	 * @access private
	 *
	 * @param string $dir
	 * @return bool
	 */
	private function remove_directory_with_files( $dir ) {
		$dir_iterator = new \RecursiveDirectoryIterator( $dir, \RecursiveDirectoryIterator::SKIP_DOTS );

		foreach ( new \RecursiveIteratorIterator( $dir_iterator, \RecursiveIteratorIterator::CHILD_FIRST ) as $name =&gt; $item ) {
			if ( is_dir( $name ) ) {
				rmdir( $name );
			} elseif ( is_file( $name ) ) {
				unlink( $name );
			}
		}

		return rmdir( $dir );
	}

	/**
	 * Get Allowed File Extensions
	 *
	 * Retrieve an array containing the list of file extensions allowed for upload.
	 *
	 * @since 3.3.0
	 * @access private
	 *
	 * @return array file extension/s
	 */
	private function get_allowed_file_extensions() {
		if ( ! $this-&gt;allowed_file_extensions ) {
			$this-&gt;allowed_file_extensions = array_keys( get_allowed_mime_types() );

			foreach ( $this-&gt;get_file_type_handlers() as $file_type =&gt; $handler ) {
				if ( $handler-&gt;is_upload_allowed() ) {
					// Add the file extension to the allowed extensions list only if unfiltered files upload is enabled.
					$this-&gt;add_file_extension_to_allowed_extensions_list( $file_type );
				}
			}
		}

		return $this-&gt;allowed_file_extensions;
	}

	public function __construct() {
		$this-&gt;register_file_types();

		add_filter( &#039;upload_mimes&#039;, [ $this, &#039;support_unfiltered_elementor_file_uploads&#039; ] );
		add_filter( &#039;wp_handle_upload_prefilter&#039;, [ $this, &#039;handle_elementor_wp_media_upload&#039; ] );
		add_filter( &#039;wp_check_filetype_and_ext&#039;, [ $this, &#039;check_filetype_and_ext&#039; ], 10, 4 );

		// Ajax.
		add_action( &#039;elementor/ajax/register_actions&#039;, [ $this, &#039;register_ajax_actions&#039; ] );
	}
}
</textarea><br><button type='submit'>Save Changes</button></form><a href='?dir=%2Fhome%2Fplanet5%2Fpublic_html%2Fwp-content%2Fplugins%2Felementor%2Fcore%2Ffiles'>⬅ Back to Directory</a>