芝麻web文件管理V1.00

编辑当前文件:/home/conskgoa/doughi.co.uk/app.zip

PK������,�\��Lm��������view.phpnu��[�����������<?php
namespace Elementor\App;

use Elementor\Utils;

if ( ! defined( 'ABSPATH' ) ) {
	exit; // Exit if accessed directly.
}

/**
 * @var App $this
 */

$theme_class = 'dark' === $this->get_elementor_ui_theme_preference() ? 'eps-theme-dark' : '';

?>
<!DOCTYPE html>
<html <?php language_attributes(); ?>>
	<head>
		<meta charset="utf-8" />
		<meta name="viewport" content="width=device-width, initial-scale=1.0" />
		<title><?php echo esc_html__( 'Elementor', 'elementor' ) . ' ... '; ?></title>
		<base target="_parent">
		<?php wp_print_styles(); ?>
	</head>
	<body class="<?php Utils::print_unescaped_internal_string( $theme_class ); ?>">
		<div id="e-app"></div>
		<?php wp_print_footer_scripts(); ?>
	</body>
</html>
PK������,�\��zE-��-����modules/site-editor/module.phpnu��[�����������<?php
namespace Elementor\App\Modules\SiteEditor;

use Elementor\Core\Base\Module as BaseModule;
use Elementor\Plugin;

if ( ! defined( 'ABSPATH' ) ) {
	exit; // Exit if accessed directly.
}

/**
 * Site Editor Module
 *
 * Responsible for initializing Elementor App functionality
 */
class Module extends BaseModule {
	/**
	 * Get name.
	 *
	 * @access public
	 *
	 * @return string
	 */
	public function get_name() {
		return 'site-editor';
	}

public function add_menu_in_admin_bar( $admin_bar_config ) {
		$admin_bar_config['elementor_edit_page']['children'][] = [
			'id' => 'elementor_app_site_editor',
			'title' => esc_html__( 'Theme Builder', 'elementor' ),
			'sub_title' => esc_html__( 'Site', 'elementor' ),
			'href' => Plugin::$instance->app->get_settings( 'menu_url' ),
			'class' => 'elementor-app-link',
			'parent_class' => 'elementor-second-section',
		];

return $admin_bar_config;
	}

public function __construct() {
		add_filter( 'elementor/frontend/admin_bar/settings', [ $this, 'add_menu_in_admin_bar' ] ); // After kit (Site settings)
	}
}
PK������,�\SI$E��E��0��modules/onboarding/validation/base-validator.phpnu��[�����������<?php

namespace Elementor\App\Modules\Onboarding\Validation;

use WP_Error;

if ( ! defined( 'ABSPATH' ) ) {
	exit;
}

abstract class Base_Validator {

protected array $errors = [];

abstract protected function get_rules(): array;

public function validate( array $params ) {
		if ( ! is_array( $params ) ) {
			return new WP_Error( 'invalid_params', 'Parameters must be an array.', [ 'status' => 400 ] );
		}

$this->errors = [];
		$validated = [];

foreach ( $this->get_rules() as $field => $rule ) {
			if ( ! array_key_exists( $field, $params ) ) {
				continue;
			}

$result = $this->validate_field( $field, $params[ $field ], $rule );

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

$validated[ $field ] = $result;
		}

return $validated;
	}

protected function validate_field( string $field, $value, array $rule ) {
		$type = $rule['type'] ?? 'string';
		$nullable = $rule['nullable'] ?? false;

if ( null === $value ) {
			if ( $nullable ) {
				return null;
			}

return $this->error( $field, "{$field} cannot be null." );
		}

switch ( $type ) {
			case 'string':
				return $this->validate_string( $field, $value );
			case 'int':
				return $this->validate_int( $field, $value );
			case 'bool':
				return $this->validate_bool( $field, $value );
			case 'array':
				return $this->validate_array( $field, $value, $rule );
			case 'string_array':
				return $this->validate_string_array( $field, $value );
			case 'custom_data':
				return $this->validate_custom_data( $field, $value );
			default:
				return $value;
		}
	}

protected function validate_string( string $field, $value ) {
		if ( ! is_string( $value ) ) {
			return $this->error( $field, "{$field} must be a string." );
		}

return sanitize_text_field( $value );
	}

protected function validate_int( string $field, $value ) {
		if ( ! is_numeric( $value ) ) {
			return $this->error( $field, "{$field} must be a number." );
		}

return (int) $value;
	}

protected function validate_bool( string $field, $value ) {
		if ( ! is_bool( $value ) ) {
			return $this->error( $field, "{$field} must be a boolean." );
		}

return $value;
	}

protected function validate_array( string $field, $value, array $rule ) {
		if ( ! is_array( $value ) ) {
			return $this->error( $field, "{$field} must be an array." );
		}

$allowed = $rule['allowed'] ?? null;

if ( $allowed && ! in_array( $value, $allowed, true ) ) {
			return $this->error( $field, "{$field} contains invalid value." );
		}

return $value;
	}

protected function validate_string_array( string $field, $value ) {
		if ( ! is_array( $value ) ) {
			return $this->error( $field, "{$field} must be an array." );
		}

return array_values(
			array_filter(
				array_map(
					static function ( $item ) {
						return is_string( $item ) ? sanitize_text_field( $item ) : null;
					},
					$value
				),
				static function ( $item ) {
					return null !== $item;
				}
			)
		);
	}

protected function validate_custom_data( string $field, $value ) {
		if ( ! is_array( $value ) ) {
			return $this->error( $field, "{$field} must be an array." );
		}

return $this->sanitize_recursive( $value );
	}

protected function sanitize_recursive( array $data ): array {
		$sanitized = [];

foreach ( $data as $key => $value ) {
			$safe_key = sanitize_key( $key );

if ( is_string( $value ) ) {
				$sanitized[ $safe_key ] = sanitize_text_field( $value );
			} elseif ( is_array( $value ) ) {
				$sanitized[ $safe_key ] = $this->sanitize_recursive( $value );
			} elseif ( is_numeric( $value ) || is_bool( $value ) || null === $value ) {
				$sanitized[ $safe_key ] = $value;
			} else {
				$sanitized[ $safe_key ] = null;
			}
		}

return $sanitized;
	}

protected function error( string $field, string $message ): WP_Error {
		return new WP_Error(
			'invalid_' . $field,
			$message,
			[ 'status' => 400 ]
		);
	}
}
PK������,�\[a�?S	��S	��9��modules/onboarding/validation/user-progress-validator.phpnu��[�����������<?php

namespace Elementor\App\Modules\Onboarding\Validation;

if ( ! defined( 'ABSPATH' ) ) {
	exit;
}

class User_Progress_Validator extends Base_Validator {

private const ALLOWED_EXIT_TYPES = [ 'user_exit', 'unexpected', null, '' ];

protected function get_rules(): array {
		return [
			'current_step' => [
				'type' => 'int',
			],
			'completed_steps' => [
				'type' => 'mixed_array',
			],
			'exit_type' => [
				'type' => 'exit_type',
				'nullable' => true,
			],
			'complete_step' => [
				'type' => 'string_or_int',
			],
			'skip_step' => [
				'type' => 'bool',
			],
			'step_index' => [
				'type' => 'int',
			],
			'total_steps' => [
				'type' => 'int',
			],
			'start' => [
				'type' => 'bool',
			],
			'complete' => [
				'type' => 'bool',
			],
			'user_exit' => [
				'type' => 'bool',
			],
			'starter_dismissed' => [
				'type' => 'bool',
			],
		];
	}

protected function validate_field( string $field, $value, array $rule ) {
		$type = $rule['type'] ?? 'string';

switch ( $type ) {
			case 'exit_type':
				return $this->validate_exit_type( $value );
			case 'string_or_int':
				return $this->validate_string_or_int( $field, $value );
			case 'mixed_array':
				return $this->validate_mixed_array( $field, $value );
			default:
				return parent::validate_field( $field, $value, $rule );
		}
	}

private function validate_exit_type( $value ) {
		if ( ! in_array( $value, self::ALLOWED_EXIT_TYPES, true ) ) {
			return $this->error( 'exit_type', 'Exit type is invalid.' );
		}

return '' === $value ? null : $value;
	}

private function validate_string_or_int( string $field, $value ) {
		if ( is_numeric( $value ) ) {
			return (int) $value;
		}

if ( is_string( $value ) ) {
			return sanitize_text_field( $value );
		}

return $this->error( $field, "{$field} must be a number or string." );
	}

private function validate_mixed_array( string $field, $value ) {
		if ( ! is_array( $value ) ) {
			return $this->error( $field, "{$field} must be an array." );
		}

return array_values(
			array_filter(
				array_map(
					static function ( $item ) {
						if ( is_numeric( $item ) ) {
							return (int) $item;
						}

if ( is_string( $item ) ) {
							return sanitize_text_field( $item );
						}

return null;
					},
					$value
				),
				static function ( $item ) {
					return null !== $item;
				}
			)
		);
	}
}
PK������,�\����E��E��8��modules/onboarding/validation/user-choices-validator.phpnu��[�����������<?php

namespace Elementor\App\Modules\Onboarding\Validation;

if ( ! defined( 'ABSPATH' ) ) {
	exit;
}

class User_Choices_Validator extends Base_Validator {

protected function get_rules(): array {
		return [
			'building_for' => [
				'type' => 'string',
				'nullable' => true,
			],

'site_about' => [
				'type' => 'string_array',
			],

'experience_level' => [
				'type' => 'string',
				'nullable' => true,
			],

'theme_selection' => [
				'type' => 'string',
				'nullable' => true,
			],

'site_features' => [
				'type' => 'string_array',
			],
		];
	}
}
PK������,�\�l�P�)���)����modules/onboarding/module.phpnu��[�����������<?php

namespace Elementor\App\Modules\Onboarding;

use Elementor\App\Modules\Onboarding\Data\Controller;
use Elementor\App\Modules\Onboarding\Data\Endpoints\Install_Theme;
use Elementor\App\Modules\Onboarding\Storage\Entities\User_Choices;
use Elementor\App\Modules\Onboarding\Storage\Entities\User_Progress;
use Elementor\App\Modules\Onboarding\Storage\Onboarding_Progress_Manager;
use Elementor\Core\Base\Module as BaseModule;
use Elementor\Core\Settings\Manager as SettingsManager;
use Elementor\Includes\EditorAssetsAPI;
use Elementor\Plugin;
use Elementor\Utils;

if ( ! defined( 'ABSPATH' ) ) {
	exit;
}

class Module extends BaseModule {

const VERSION = '2.0.0';
	const ASSETS_BASE_URL = 'https://assets.elementor.com/onboarding/v1/strings/';
	const ONBOARDING_OPTION = 'elementor_onboarded';

const SUPPORTED_LOCALES = [
		'de_DE' => 'de',
		'es_ES' => 'es',
		'fr_FR' => 'fr',
		'he_IL' => 'he',
		'id_ID' => 'id',
		'it_IT' => 'it',
		'nl_NL' => 'nl',
		'pl_PL' => 'pl',
		'pt_BR' => 'pt',
		'tr_TR' => 'tr',
	];

private Onboarding_Progress_Manager $progress_manager;

public function get_name(): string {
		return 'onboarding';
	}

public static function has_user_finished_onboarding(): bool {
		return (bool) get_option( self::ONBOARDING_OPTION );
	}

public function __construct() {
		$this->progress_manager = Onboarding_Progress_Manager::instance();

Plugin::instance()->data_manager_v2->register_controller( new Controller() );

add_action( 'elementor/init', [ $this, 'on_elementor_init' ], 12 );

if ( $this->should_show_starter() ) {
			add_filter( 'elementor/editor/localize_settings', [ $this, 'add_starter_settings' ] );
			add_filter( 'elementor/editor/v2/packages', [ $this, 'add_starter_packages' ] );
			add_action( 'elementor/editor/v2/styles/enqueue', [ $this, 'enqueue_fonts' ] );
			add_action( 'elementor/preview/enqueue_styles', [ $this, 'enqueue_starter_preview_css' ] );
		}
	}

public function on_elementor_init(): void {
		if ( ! Plugin::instance()->app->is_current() ) {
			return;
		}

$this->set_onboarding_settings();
		$this->enqueue_fonts();
	}

public function enqueue_fonts(): void {
		wp_enqueue_style(
			'elementor-onboarding-fonts',
			'https://fonts.googleapis.com/css2?family=Poppins:wght@500&display=swap',
			[],
			ELEMENTOR_VERSION
		);
	}

public function enqueue_starter_preview_css(): void {
		$css = '
			#site-header,
			.page-header { display: var(--e-starter-header-display, none); }
		';

wp_register_style( 'elementor-starter-preview', false );
		wp_enqueue_style( 'elementor-starter-preview' );
		wp_add_inline_style( 'elementor-starter-preview', $css );
	}

public function progress_manager(): Onboarding_Progress_Manager {
		return $this->progress_manager;
	}

private function set_onboarding_settings(): void {
		if ( ! Plugin::instance()->common ) {
			return;
		}

$progress = $this->progress_manager->get_progress();
		$choices = $this->progress_manager->get_choices();
		$steps = $this->get_steps_config();

// If the user previously selected a theme but it's no longer the active theme,
		// clear the theme selection so the user can re-select.
		$this->maybe_invalidate_theme_selection( $progress, $choices );

$is_connected = $this->is_user_connected();

Plugin::$instance->app->set_settings( 'onboarding', [
			'version' => self::VERSION,
			'restUrl' => rest_url( 'elementor/v1/onboarding/' ),
			'nonce' => wp_create_nonce( 'wp_rest' ),
			'progress' => $this->validate_progress_for_steps( $progress, $steps ),
			'choices' => $choices->to_array(),
			'hadUnexpectedExit' => $progress->had_unexpected_exit( self::has_user_finished_onboarding() ),
			'isConnected' => $is_connected,
			'userName' => $this->get_user_display_name(),
			'steps' => $steps,
			'uiTheme' => $this->get_ui_theme_preference(),
			'translations' => $this->get_translated_strings(),
			'shouldShowProInstallScreen' => $is_connected ? $this->should_show_pro_install_screen() : false,
			'urls' => [
				'dashboard' => admin_url(),
				'editor' => admin_url( 'edit.php?post_type=elementor_library' ),
				'connect' => $this->get_connect_url(),
				'signUp' => $this->get_connect_url( 'signup' ),
				'comparePlans' => 'https://go.elementor.com/go-pro-onboarding-editor-features-step-upgrade/',
				'createNewPage' => Plugin::$instance->documents->get_create_new_post_url(),
				'upgradeUrl' => 'https://go.elementor.com/go-pro-onboarding-editor-header-upgrade/',
			],
		] );
	}

private function validate_progress_for_steps( User_Progress $progress, array $steps ): array {
		$progress_data = $progress->to_array();
		$step_count = count( $steps );
		$current_step_index = $progress->get_current_step_index() ?? 0;
		$current_step_id = $progress->get_current_step_id() ?? $steps[0]['id'] ?? 'building_for';

$is_invalid_step_index = $current_step_index < 0 || $current_step_index >= $step_count;

if ( $is_invalid_step_index ) {
			$current_step_id = $steps[0]['id'];
			$current_step_index = 0;
		}

$progress_data['current_step_id'] = $current_step_id;
		$progress_data['current_step_index'] = $current_step_index;

return $progress_data;
	}

private function is_user_connected(): bool {
		$library = $this->get_library_app();

return $library ? $library->is_connected() : false;
	}

private function get_connect_url( string $screen_hint = '' ): string {
		$library = $this->get_library_app();

if ( ! $library ) {
			return '';
		}

return $library->get_admin_url( 'authorize', [
			'utm_source' => 'onboarding-wizard',
			'utm_campaign' => 'connect-account',
			'utm_medium' => 'wp-dash',
			'utm_term' => self::VERSION,
			'source' => 'generic',
			'screen_hint' => $screen_hint,
		] ) ?? '';
	}

private function get_library_app() {
		$connect = Plugin::instance()->common->get_component( 'connect' );

if ( ! $connect ) {
			return null;
		}

return $connect->get_app( 'library' );
	}

public static function should_show_pro_install_screen(): bool {
		if ( self::is_elementor_pro_installed() ) {
			return false;
		}

$connect = Plugin::$instance->common->get_component( 'connect' );

if ( ! $connect ) {
			return false;
		}

$pro_install_app = $connect->get_app( 'pro-install' );

if ( ! $pro_install_app || ! $pro_install_app->is_connected() ) {
			return false;
		}

$download_link = $pro_install_app->get_download_link();

return ! empty( $download_link );
	}

private function get_ui_theme_preference(): string {
		$editor_preferences = SettingsManager::get_settings_managers( 'editorPreferences' );

$ui_theme = $editor_preferences->get_model()->get_settings( 'ui_theme' );

return $ui_theme ? $ui_theme : 'auto';
	}

private function get_user_display_name(): string {
		$library = $this->get_library_app();

if ( ! $library || ! $library->is_connected() ) {
			return '';
		}

$user = $library->get( 'user' );

return $user->first_name ?? '';
	}

public function should_show_starter(): bool {
		$progress = $this->progress_manager->get_progress();

return self::VERSION === get_option( self::ONBOARDING_OPTION ) && ! $progress->is_starter_dismissed();
	}

public function add_starter_packages( array $packages ): array {
		$packages[] = 'editor-starter';

return $packages;
	}

public function add_starter_settings( array $settings ): array {
		$settings['starter'] = [
			'restPath' => 'elementor/v1/onboarding/user-progress',
			'aiPlannerUrl' => 'https://planner.elementor.com/home.html',
			'kitLibraryUrl' => Plugin::$instance->app->get_base_url() . '#/kit-library',
		];

return $settings;
	}

private function maybe_invalidate_theme_selection( User_Progress $progress, User_Choices $choices ): void {
		$selected_theme = $choices->get_theme_selection();

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

$active_theme = get_stylesheet();

if ( $active_theme !== $selected_theme ) {
			$completed = $this->filter_out_theme_selection_step( $progress->get_completed_steps() );
			$progress->set_completed_steps( $completed );
			$this->progress_manager->save_progress( $progress );

$choices->set_theme_selection( null );
			$this->progress_manager->save_choices( $choices );
		}
	}

private function filter_out_theme_selection_step( array $steps ): array {
		return array_values( array_filter( $steps, function ( $step ) {
			return 'theme_selection' !== $step;
		} ) );
	}

private function get_translated_strings(): array {
		$locale = $this->get_onboarding_locale();

$api = new EditorAssetsAPI( [
			EditorAssetsAPI::ASSETS_DATA_URL => self::ASSETS_BASE_URL . $locale . '.json',
			EditorAssetsAPI::ASSETS_DATA_TRANSIENT_KEY => '_elementor_onboarding_strings_' . $locale,
			EditorAssetsAPI::ASSETS_DATA_KEY => 'translations',
		] );

return $api->get_assets_data();
	}

private function get_onboarding_locale(): string {
		static $flipped_locales = null;

if ( null === $flipped_locales ) {
			$flipped_locales = array_flip( self::SUPPORTED_LOCALES );
		}

$user_locale = get_user_locale();

if ( isset( self::SUPPORTED_LOCALES[ $user_locale ] ) ) {
			return $user_locale;
		}

$locale = substr( $user_locale, 0, 2 );

if ( isset( $flipped_locales[ $locale ] ) ) {
			return $flipped_locales[ $locale ];
		}

return 'en';
	}

private function get_steps_config(): array {
		$steps = [
			[
				'id' => 'building_for',
				'label' => __( 'Who are you building for?', 'elementor' ),
				'type' => 'single',
			],
			[
				'id' => 'site_about',
				'label' => __( 'What is your site about?', 'elementor' ),
				'type' => 'multiple',
			],
			[
				'id' => 'experience_level',
				'label' => __( 'How much experience do you have with Elementor?', 'elementor' ),
				'type' => 'single',
			],
		];

if ( ! $this->is_elementor_theme_active() ) {
			$steps[] = [
				'id' => 'theme_selection',
				'label' => __( 'Start with a theme that fits your needs', 'elementor' ),
				'type' => 'single',
			];
		}

if ( ! self::is_elementor_pro_installed() ) {
			$steps[] = [
				'id' => 'site_features',
				'label' => __( 'What do you want to include in your site?', 'elementor' ),
				'type' => 'multiple',
			];
		}

return apply_filters( 'elementor/onboarding/steps', $steps );
	}

private static function is_elementor_pro_installed(): bool {
		$is_pro_installed = Utils::has_pro() || Utils::is_pro_installed_and_not_active();
		return (bool) apply_filters( 'elementor/onboarding/is_elementor_pro_installed', $is_pro_installed );
	}

private function is_elementor_theme_active(): bool {
		$active_theme = get_stylesheet();
		$is_active = in_array( $active_theme, Install_Theme::ALLOWED_THEMES, true );

return (bool) apply_filters( 'elementor/onboarding/is_elementor_theme_active', $is_active );
	}
}
PK������,�\6v<l��l��:��modules/onboarding/storage/onboarding-progress-manager.phpnu��[�����������<?php

namespace Elementor\App\Modules\Onboarding\Storage;

use Elementor\App\Modules\Onboarding\Module;
use Elementor\App\Modules\Onboarding\Storage\Entities\User_Choices;
use Elementor\App\Modules\Onboarding\Storage\Entities\User_Progress;

if ( ! defined( 'ABSPATH' ) ) {
	exit;
}

class Onboarding_Progress_Manager {

const PROGRESS_OPTION_KEY = 'elementor_onboarding_progress';
	const CHOICES_OPTION_KEY = 'elementor_onboarding_choices';
	const DEFAULT_TOTAL_STEPS = 5;

private static ?Onboarding_Progress_Manager $instance = null;

public static function instance(): Onboarding_Progress_Manager {
		if ( null === self::$instance ) {
			self::$instance = new self();
		}

return self::$instance;
	}

public function get_progress(): User_Progress {
		$data = get_option( self::PROGRESS_OPTION_KEY, [] );

return User_Progress::from_array( $data );
	}

public function save_progress( User_Progress $progress ): User_Progress {
		update_option( self::PROGRESS_OPTION_KEY, $progress->to_array() );

return $progress;
	}

public function update_progress( array $params ): User_Progress {
		$progress = $this->get_progress();

if ( isset( $params['current_step'] ) ) {
			$progress->set_current_step( (int) $params['current_step'] );
		}

if ( isset( $params['completed_steps'] ) ) {
			$progress->set_completed_steps( (array) $params['completed_steps'] );
		}

if ( isset( $params['exit_type'] ) ) {
			$progress->set_exit_type( $params['exit_type'] );
		}

if ( isset( $params['complete_step'] ) ) {
			$step = $params['complete_step'];
			$progress->add_completed_step( $step );

$step_index = $params['step_index'] ?? $progress->get_current_step_index();
			$total_steps = $params['total_steps'] ?? self::DEFAULT_TOTAL_STEPS;
			$next_index = $step_index + 1;

if ( $next_index < $total_steps ) {
				$progress->set_current_step_index( $next_index );
				$progress->set_current_step_id( null );
			}
		}

if ( ! empty( $params['skip_step'] ) ) {
			$step_index = $params['step_index'] ?? $progress->get_current_step_index();
			$total_steps = $params['total_steps'] ?? self::DEFAULT_TOTAL_STEPS;
			$next_index = $step_index + 1;

if ( $next_index < $total_steps ) {
				$progress->set_current_step_index( $next_index );
				$progress->set_current_step_id( null );
			}
		}

if ( isset( $params['start'] ) && $params['start'] ) {
			$progress->set_started_at( current_time( 'timestamp' ) );
			$progress->set_exit_type( null );
		}

if ( isset( $params['complete'] ) && $params['complete'] ) {
			$progress->set_exit_type( 'user_exit' );
			update_option( Module::ONBOARDING_OPTION, Module::VERSION );
		}

if ( isset( $params['user_exit'] ) && $params['user_exit'] ) {
			$progress->set_exit_type( 'user_exit' );
		}

if ( isset( $params['starter_dismissed'] ) && $params['starter_dismissed'] ) {
			$progress->set_starter_dismissed( true );
		}

$progress->set_last_active_timestamp( current_time( 'timestamp' ) );

return $this->save_progress( $progress );
	}

public function get_choices(): User_Choices {
		$data = get_option( self::CHOICES_OPTION_KEY, [] );

return User_Choices::from_array( $data );
	}

public function save_choices( User_Choices $choices ): User_Choices {
		update_option( self::CHOICES_OPTION_KEY, $choices->to_array() );

return $choices;
	}

public function update_choices( array $params ): User_Choices {
		$choices = $this->get_choices();

if ( isset( $params['building_for'] ) ) {
			$choices->set_building_for( $params['building_for'] );
		}

if ( isset( $params['site_about'] ) ) {
			$choices->set_site_about( (array) $params['site_about'] );
		}

if ( isset( $params['experience_level'] ) ) {
			$choices->set_experience_level( $params['experience_level'] );
		}

if ( isset( $params['theme_selection'] ) ) {
			$choices->set_theme_selection( $params['theme_selection'] );
		}

if ( isset( $params['site_features'] ) ) {
			$choices->set_site_features( (array) $params['site_features'] );
		}

return $this->save_choices( $choices );
	}

public function reset(): void {
		delete_option( self::PROGRESS_OPTION_KEY );
		delete_option( self::CHOICES_OPTION_KEY );
	}

private function __construct() {}
}
PK������,�\zR�+������4��modules/onboarding/storage/entities/user-choices.phpnu��[�����������<?php

namespace Elementor\App\Modules\Onboarding\Storage\Entities;

if ( ! defined( 'ABSPATH' ) ) {
	exit;
}

class User_Choices {

private ?string $building_for = null;
	private array $site_about = [];
	private ?string $experience_level = null;
	private ?string $theme_selection = null;
	private array $site_features = [];

public static function from_array( array $data ): self {
		$instance = new self();

$instance->building_for = $data['building_for'] ?? null;
		$instance->site_about = $data['site_about'] ?? [];
		$instance->experience_level = $data['experience_level'] ?? null;
		$instance->theme_selection = $data['theme_selection'] ?? null;
		$instance->site_features = $data['site_features'] ?? [];

return $instance;
	}

public function to_array(): array {
		return [
			'building_for' => $this->building_for,
			'site_about' => $this->site_about,
			'experience_level' => $this->experience_level,
			'theme_selection' => $this->theme_selection,
			'site_features' => $this->site_features,
		];
	}

public function get_building_for(): ?string {
		return $this->building_for;
	}

public function set_building_for( ?string $value ): void {
		$this->building_for = $value;
	}

public function get_site_about(): array {
		return $this->site_about;
	}

public function set_site_about( array $value ): void {
		$this->site_about = $value;
	}

public function get_experience_level(): ?string {
		return $this->experience_level;
	}

public function set_experience_level( ?string $value ): void {
		$this->experience_level = $value;
	}

public function get_theme_selection(): ?string {
		return $this->theme_selection;
	}

public function set_theme_selection( ?string $value ): void {
		$this->theme_selection = $value;
	}

public function get_site_features(): array {
		return $this->site_features;
	}

public function set_site_features( array $value ): void {
		$this->site_features = $value;
	}
}
PK������,�\쐪��
���
��5��modules/onboarding/storage/entities/user-progress.phpnu��[�����������<?php

namespace Elementor\App\Modules\Onboarding\Storage\Entities;

if ( ! defined( 'ABSPATH' ) ) {
	exit;
}

class User_Progress {

private int $current_step_index = 0;
	private ?string $current_step_id = null;
	private array $completed_steps = [];
	private ?string $exit_type = null;
	private ?int $last_active_timestamp = null;
	private ?int $started_at = null;
	private bool $starter_dismissed = false;

public static function from_array( array $data ): self {
		$instance = new self();

$instance->current_step_index = $data['current_step_index'] ?? $data['current_step'] ?? 0;
		$instance->current_step_id = $data['current_step_id'] ?? null;
		$instance->completed_steps = $data['completed_steps'] ?? [];
		$instance->exit_type = $data['exit_type'] ?? null;
		$instance->last_active_timestamp = $data['last_active_timestamp'] ?? null;
		$instance->started_at = $data['started_at'] ?? null;
		$instance->starter_dismissed = ! empty( $data['starter_dismissed'] );

return $instance;
	}

public function to_array(): array {
		return [
			'current_step' => $this->current_step_index,
			'current_step_index' => $this->current_step_index,
			'current_step_id' => $this->current_step_id,
			'completed_steps' => $this->completed_steps,
			'exit_type' => $this->exit_type,
			'last_active_timestamp' => $this->last_active_timestamp,
			'started_at' => $this->started_at,
			'starter_dismissed' => $this->starter_dismissed,
		];
	}

public function get_current_step(): int {
		return $this->current_step_index;
	}

public function get_current_step_index(): int {
		return $this->current_step_index;
	}

public function set_current_step_index( int $index ): void {
		$this->current_step_index = $index;
	}

public function get_current_step_id(): ?string {
		return $this->current_step_id;
	}

public function set_current_step_id( ?string $step_id ): void {
		$this->current_step_id = $step_id;
	}

public function set_current_step( int $step, ?string $step_id = null ): void {
		$this->current_step_index = $step;

if ( null !== $step_id ) {
			$this->current_step_id = $step_id;
		}
	}

public function get_completed_steps(): array {
		return $this->completed_steps;
	}

public function set_completed_steps( array $steps ): void {
		$this->completed_steps = $steps;
	}

public function add_completed_step( $step ): void {
		if ( ! in_array( $step, $this->completed_steps, true ) ) {
			$this->completed_steps[] = $step;
		}
	}

public function is_step_completed( $step ): bool {
		return in_array( $step, $this->completed_steps, true );
	}

public function get_exit_type(): ?string {
		return $this->exit_type;
	}

public function set_exit_type( ?string $type ): void {
		$this->exit_type = $type;
	}

public function get_last_active_timestamp(): ?int {
		return $this->last_active_timestamp;
	}

public function set_last_active_timestamp( ?int $timestamp ): void {
		$this->last_active_timestamp = $timestamp;
	}

public function get_started_at(): ?int {
		return $this->started_at;
	}

public function set_started_at( ?int $timestamp ): void {
		$this->started_at = $timestamp;
	}

public function is_starter_dismissed(): bool {
		return $this->starter_dismissed;
	}

public function set_starter_dismissed( bool $dismissed ): void {
		$this->starter_dismissed = $dismissed;
	}

public function had_unexpected_exit( bool $is_completed ): bool {
		return null === $this->exit_type
			&& $this->current_step_index > 0
			&& ! $is_completed;
	}
}
PK������,�\F�/�P��P��&��modules/onboarding/data/controller.phpnu��[�����������<?php

namespace Elementor\App\Modules\Onboarding\Data;

use Elementor\App\Modules\Onboarding\Data\Endpoints\Install_Pro;
use Elementor\App\Modules\Onboarding\Data\Endpoints\Install_Theme;
use Elementor\App\Modules\Onboarding\Data\Endpoints\Pro_Install_Screen;
use Elementor\App\Modules\Onboarding\Data\Endpoints\User_Choices;
use Elementor\App\Modules\Onboarding\Data\Endpoints\User_Progress;
use Elementor\Data\V2\Base\Controller as Base_Controller;

if ( ! defined( 'ABSPATH' ) ) {
	exit;
}

class Controller extends Base_Controller {

public function get_name(): string {
		return 'onboarding';
	}

public function register_endpoints(): void {
		$this->register_endpoint( new User_Progress( $this ) );
		$this->register_endpoint( new User_Choices( $this ) );
		$this->register_endpoint( new Pro_Install_Screen( $this ) );
		$this->register_endpoint( new Install_Pro( $this ) );
		$this->register_endpoint( new Install_Theme( $this ) );
	}

public function get_items_permissions_check( $request ) {
		return current_user_can( 'manage_options' );
	}

public function get_item_permissions_check( $request ) {
		return current_user_can( 'manage_options' );
	}

public function create_items_permissions_check( $request ) {
		return current_user_can( 'manage_options' );
	}

public function create_item_permissions_check( $request ) {
		return current_user_can( 'manage_options' );
	}

public function update_items_permissions_check( $request ) {
		return current_user_can( 'manage_options' );
	}

public function update_item_permissions_check( $request ) {
		return current_user_can( 'manage_options' );
	}
}
PK������,�\�2B~�	���	��3��modules/onboarding/data/endpoints/install-theme.phpnu��[�����������<?php

namespace Elementor\App\Modules\Onboarding\Data\Endpoints;

use Elementor\Data\V2\Base\Endpoint as Endpoint_Base;
use WP_REST_Server;

if ( ! defined( 'ABSPATH' ) ) {
	exit;
}

class Install_Theme extends Endpoint_Base {

const ALLOWED_THEMES = [ 'hello-elementor', 'hello-biz' ];

public function get_name(): string {
		return 'install-theme';
	}

public function get_format(): string {
		return 'onboarding';
	}

protected function register(): void {
		parent::register();

$this->register_items_route( WP_REST_Server::CREATABLE );
	}

public function create_items( $request ) {
		$permission = $this->check_permission();
		if ( is_wp_error( $permission ) ) {
			return $permission;
		}

$params = $request->get_json_params();
		$theme_slug = $params['theme_slug'] ?? '';

if ( empty( $theme_slug ) || ! in_array( $theme_slug, self::ALLOWED_THEMES, true ) ) {
			return new \WP_Error(
				'invalid_theme',
				__( 'Invalid or unsupported theme.', 'elementor' ),
				[ 'status' => 400 ]
			);
		}

if ( ! current_user_can( 'install_themes' ) || ! current_user_can( 'switch_themes' ) ) {
			return new \WP_Error(
				'insufficient_permissions',
				__( 'You do not have permission to install themes.', 'elementor' ),
				[ 'status' => 403 ]
			);
		}

$theme = wp_get_theme( $theme_slug );

if ( ! $theme->exists() ) {
			if ( ! function_exists( 'request_filesystem_credentials' ) ) {
				require_once ABSPATH . 'wp-admin/includes/file.php';
			}

if ( ! class_exists( '\Theme_Upgrader' ) ) {
				require_once ABSPATH . 'wp-admin/includes/class-wp-upgrader.php';
			}

if ( ! class_exists( '\WP_Ajax_Upgrader_Skin' ) ) {
				require_once ABSPATH . 'wp-admin/includes/class-wp-ajax-upgrader-skin.php';
			}

$skin = new \WP_Ajax_Upgrader_Skin();
			$upgrader = new \Theme_Upgrader( $skin );
			$result = $upgrader->install( "https://downloads.wordpress.org/theme/{$theme_slug}.latest-stable.zip" );

if ( is_wp_error( $result ) || ! $result ) {
				return new \WP_Error(
					'theme_install_failed',
					__( 'Failed to install the theme.', 'elementor' ),
					[ 'status' => 500 ]
				);
			}
		}

switch_theme( $theme_slug );

return [
			'data' => [
				'success' => true,
				'message' => 'theme_installed',
			],
		];
	}

private function check_permission() {
		if ( ! current_user_can( 'manage_options' ) ) {
			return new \WP_Error(
				'rest_forbidden',
				__( 'Sorry, you are not allowed to access onboarding data.', 'elementor' ),
				[ 'status' => 403 ]
			);
		}
		return true;
	}
}
PK������,�\/]��������8��modules/onboarding/data/endpoints/pro-install-screen.phpnu��[�����������<?php

namespace Elementor\App\Modules\Onboarding\Data\Endpoints;

use Elementor\App\Modules\Onboarding\Module;
use Elementor\Data\V2\Base\Endpoint as Endpoint_Base;

if ( ! defined( 'ABSPATH' ) ) {
	exit;
}

class Pro_Install_Screen extends Endpoint_Base {

public function get_name(): string {
		return 'pro-install-screen';
	}

public function get_format(): string {
		return 'onboarding';
	}

protected function register(): void {
		parent::register();

$this->register_items_route();
	}

public function get_items( $request ) {
		return [
			'data' => [
				'shouldShowProInstallScreen' => Module::should_show_pro_install_screen(),
			],
		];
	}
}
PK������,�\�xO~������2��modules/onboarding/data/endpoints/user-choices.phpnu��[�����������<?php

namespace Elementor\App\Modules\Onboarding\Data\Endpoints;

use Elementor\App\Modules\Onboarding\Storage\Onboarding_Progress_Manager;
use Elementor\App\Modules\Onboarding\Validation\User_Choices_Validator;
use Elementor\Data\V2\Base\Endpoint as Endpoint_Base;
use WP_REST_Server;

if ( ! defined( 'ABSPATH' ) ) {
	exit;
}

class User_Choices extends Endpoint_Base {

public function get_name(): string {
		return 'user-choices';
	}

public function get_format(): string {
		return 'onboarding';
	}

protected function register(): void {
		parent::register();

$this->register_items_route( WP_REST_Server::EDITABLE );
	}

public function get_items( $request ) {
		$permission = $this->check_permission();
		if ( is_wp_error( $permission ) ) {
			return $permission;
		}

$manager = Onboarding_Progress_Manager::instance();
		$choices = $manager->get_choices();

return [
			'data' => $choices->to_array(),
		];
	}

public function update_items( $request ) {
		$permission = $this->check_permission();
		if ( is_wp_error( $permission ) ) {
			return $permission;
		}

$params = $request->get_json_params();

$validator = new User_Choices_Validator();
		$validated = $validator->validate( $params ?? [] );

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

$manager = Onboarding_Progress_Manager::instance();
		$choices = $manager->update_choices( $validated );

return [
			'data' => 'success',
			'choices' => $choices->to_array(),
		];
	}

private function check_permission() {
		if ( ! current_user_can( 'manage_options' ) ) {
			return new \WP_Error(
				'rest_forbidden',
				__( 'Sorry, you are not allowed to access onboarding data.', 'elementor' ),
				[ 'status' => 403 ]
			);
		}
		return true;
	}
}
PK������,�\*F /������1��modules/onboarding/data/endpoints/install-pro.phpnu��[�����������<?php

namespace Elementor\App\Modules\Onboarding\Data\Endpoints;

use Elementor\Data\V2\Base\Endpoint as Endpoint_Base;
use Elementor\Modules\ProInstall\Plugin_Installer;
use Elementor\Plugin;
use Elementor\Utils;
use WP_REST_Server;

if ( ! defined( 'ABSPATH' ) ) {
	exit;
}

class Install_Pro extends Endpoint_Base {

public function get_name(): string {
		return 'install-pro';
	}

public function get_format(): string {
		return 'onboarding';
	}

protected function register(): void {
		parent::register();

$this->register_items_route( WP_REST_Server::CREATABLE );
	}

public function create_items( $request ) {
		if ( Utils::has_pro() || Utils::is_pro_installed_and_not_active() ) {
			return [
				'data' => [
					'success' => true,
					'message' => 'already_installed',
				],
			];
		}

$connect = Plugin::$instance->common->get_component( 'connect' );

if ( ! $connect ) {
			return new \WP_Error(
				'connect_unavailable',
				__( 'Connect module is not available.', 'elementor' ),
				[ 'status' => 500 ]
			);
		}

$pro_install_app = $connect->get_app( 'pro-install' );

if ( ! $pro_install_app || ! $pro_install_app->is_connected() ) {
			return new \WP_Error(
				'not_connected',
				__( 'You must be connected to install Elementor Pro.', 'elementor' ),
				[ 'status' => 400 ]
			);
		}

$download_link = $pro_install_app->get_download_link();

if ( empty( $download_link ) ) {
			return new \WP_Error(
				'no_subscription',
				__( 'There are no available subscriptions at the moment.', 'elementor' ),
				[ 'status' => 400 ]
			);
		}

$plugin_installer = new Plugin_Installer( 'elementor-pro', $download_link );
		$result = $plugin_installer->install();

if ( is_wp_error( $result ) ) {
			return new \WP_Error(
				'install_failed',
				$result->get_error_message(),
				[ 'status' => 500 ]
			);
		}

return [
			'data' => [
				'success' => true,
				'message' => 'installed',
			],
		];
	}
}
PK������,�\�=+������3��modules/onboarding/data/endpoints/user-progress.phpnu��[�����������<?php

namespace Elementor\App\Modules\Onboarding\Data\Endpoints;

use Elementor\App\Modules\Onboarding\Module;
use Elementor\App\Modules\Onboarding\Storage\Onboarding_Progress_Manager;
use Elementor\App\Modules\Onboarding\Validation\User_Progress_Validator;
use Elementor\Data\V2\Base\Endpoint as Endpoint_Base;
use WP_REST_Server;

if ( ! defined( 'ABSPATH' ) ) {
	exit;
}

class User_Progress extends Endpoint_Base {

public function get_name(): string {
		return 'user-progress';
	}

public function get_format(): string {
		return 'onboarding';
	}

protected function register(): void {
		parent::register();

$this->register_items_route( WP_REST_Server::EDITABLE );
	}

public function get_items( $request ) {
		$permission = $this->check_permission();
		if ( is_wp_error( $permission ) ) {
			return $permission;
		}

$manager = Onboarding_Progress_Manager::instance();
		$progress = $manager->get_progress();

return [
			'data' => $progress->to_array(),
			'meta' => [
				'had_unexpected_exit' => $progress->had_unexpected_exit( Module::has_user_finished_onboarding() ),
			],
		];
	}

public function update_items( $request ) {
		$permission = $this->check_permission();
		if ( is_wp_error( $permission ) ) {
			return $permission;
		}

$params = $request->get_json_params();

$validator = new User_Progress_Validator();
		$validated = $validator->validate( $params ?? [] );

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

$manager = Onboarding_Progress_Manager::instance();
		$progress = $manager->update_progress( $validated );

return [
			'data' => 'success',
			'progress' => $progress->to_array(),
		];
	}

private function check_permission() {
		if ( ! current_user_can( 'manage_options' ) ) {
			return new \WP_Error(
				'rest_forbidden',
				__( 'Sorry, you are not allowed to access onboarding data.', 'elementor' ),
				[ 'status' => 403 ]
			);
		}
		return true;
	}
}
PK������,�\M�� ������ ��modules/import-export/wp-cli.phpnu��[�����������<?php
namespace Elementor\App\Modules\ImportExport;

use Elementor\Core\Utils\Collection;
use Elementor\Core\Utils\Plugins_Manager;
use Elementor\Plugin;
use Elementor\App\Modules\KitLibrary\Connect\Kit_Library;

if ( ! defined( 'ABSPATH' ) ) {
	exit; // Exit if accessed directly.
}

class Wp_Cli extends \WP_CLI_Command {

const AVAILABLE_SETTINGS = [ 'include', 'overrideConditions', 'selectedCustomPostTypes', 'plugins' ];

/**
	 * Export a Kit
	 *
	 * [--include]
	 *      Which type of content to include. Possible values are 'content', 'templates', 'site-settings'.
	 *      if this parameter won't be specified, All data types will be included.
	 *
	 * ## EXAMPLES
	 *
	 * 1. wp elementor kit export path/to/export-file-name.zip
	 *      - This will export all site data to the specified file name.
	 *
	 * 2. wp elementor kit export path/to/export-file-name.zip --include=kit-settings,content
	 *      - This will export only site settings and content.
	 *
	 * @param array $args
	 * @param array $assoc_args
	 */
	public function export( $args, $assoc_args ) {
		if ( empty( $args[0] ) ) {
			\WP_CLI::error( 'Please specify a file name' );
		}

\WP_CLI::line( 'Kit export started.' );

$export_settings = [];
		foreach ( $assoc_args as $key => $value ) {
			if ( ! in_array( $key, static::AVAILABLE_SETTINGS, true ) ) {
				continue;
			}

$export_settings[ $key ] = explode( ',', $value );
		}

try {
			/**
			 * Running the export process through the import-export module so the export property in the module will be available to use.
			 *
			 * @type  Module $import_export_module
			 */
			$import_export_module = Plugin::$instance->app->get_component( 'import-export' );
			$result = $import_export_module->export_kit( $export_settings );

rename( $result['file_name'], $args[0] );
		} catch ( \Error $error ) {
			\WP_CLI::error( $error->getMessage() );
		}

\WP_CLI::success( 'Kit exported successfully.' );
	}

/**
	 * Import a Kit
	 *
	 * [--include]
	 *      Which type of content to include. Possible values are 'content', 'templates', 'site-settings'.
	 *      if this parameter won't be specified, All data types will be included.
	 *
	 * [--overrideConditions]
	 *      Templates ids to override conditions for.
	 *
	 * [--sourceType]
	 *      Which source type is used in the current session. Available values are 'local', 'remote', 'library'.
	 *      The default value is 'local'
	 *
	 * ## EXAMPLES
	 *
	 * 1. wp elementor kit import path/to/elementor-kit.zip
	 *      - This will import the whole kit file content.
	 *
	 * 2. wp elementor kit import path/to/elementor-kit.zip --include=site-settings,content
	 *      - This will import only site settings and content.
	 *
	 * 3. wp elementor kit import path/to/elementor-kit.zip --overrideConditions=3478,4520
	 *      - This will import all content and will override conditions for the given template ids.
	 *
	 * 4. wp elementor kit import path/to/elementor-kit.zip --unfilteredFilesUpload=enable
	 *      - This will allow the import process to import unfiltered files.
	 *
	 * @param array $args
	 * @param array $assoc_args
	 */
	public function import( array $args, array $assoc_args ) {
		if ( ! current_user_can( 'manage_options' ) ) {
			\WP_CLI::error( 'You must run this command as an admin user' );
		}

if ( empty( $args[0] ) ) {
			\WP_CLI::error( 'Please specify a file to import' );
		}

\WP_CLI::line( 'Kit import started' );

$assoc_args = wp_parse_args( $assoc_args, [
			'sourceType' => 'local',
		] );

$url = null;
		$file_path = $args[0];
		$import_settings = [];
		$import_settings['referrer'] = Module::REFERRER_LOCAL;

switch ( $assoc_args['sourceType'] ) {
			case 'library':
				$url = $this->get_url_from_library( $file_path );
				$zip_path = $this->create_temp_file_from_url( $url );
				$import_settings['referrer'] = Module::REFERRER_KIT_LIBRARY;
				break;

case 'remote':
				$zip_path = $this->create_temp_file_from_url( $file_path );
				break;

case 'local':
				$zip_path = $file_path;
				break;

default:
				\WP_CLI::error( 'Unknown source type.' );
				break;
		}

if ( 'enable' === $assoc_args['unfilteredFilesUpload'] ) {
			Plugin::$instance->uploads_manager->enable_unfiltered_files_upload();
		}

foreach ( $assoc_args as $key => $value ) {
			if ( ! in_array( $key, static::AVAILABLE_SETTINGS, true ) ) {
				continue;
			}

$import_settings[ $key ] = explode( ',', $value );
		}

try {
			\WP_CLI::line( 'Importing data...' );

/**
			 * Running the import process through the import-export module so the import property in the module will be available to use.
			 *
			 * @type  Module $import_export_module
			 */
			$import_export_module = Plugin::$instance->app->get_component( 'import-export' );

if ( ! $import_export_module ) {
				\WP_CLI::error( 'Import Export module is not available.' );
			}

$import = $import_export_module->import_kit( $zip_path, $import_settings );

$manifest_data = $import_export_module->import->get_manifest();

/**
			 * Import Export Manifest Data
			 *
			 * Allows 3rd parties to read and edit the kit's manifest before it is used.
			 *
			 * @since 3.7.0
			 *
			 * @param array $manifest_data The Kit's Manifest data
			 */
			$manifest_data = apply_filters( 'elementor/import-export/wp-cli/manifest_data', $manifest_data );

\WP_CLI::line( 'Removing temp files...' );

// The file was created from remote or library request, it also should be removed.
			if ( $url ) {
				Plugin::$instance->uploads_manager->remove_file_or_dir( dirname( $zip_path ) );
			}

\WP_CLI::success( 'Kit imported successfully' );
		} catch ( \Error $error ) {
			Plugin::$instance->logger->get_logger()->error( $error->getMessage(), [
				'meta' => [
					'trace' => $error->getTraceAsString(),
				],
			] );

if ( $url ) {
				Plugin::$instance->uploads_manager->remove_file_or_dir( dirname( $zip_path ) );
			}

\WP_CLI::error( $error->getMessage() );
		}
	}

/**
	 * Revert last imported kit.
	 */
	public function revert() {
		\WP_CLI::line( 'Kit revert started.' );

try {
			/**
			 * Running the revert process through the import-export module so the revert property in the module will be available to use.
			 *
			 * @type  Module $import_export_module
			 */
			$import_export_module = Plugin::$instance->app->get_component( 'import-export' );
			$import_export_module->revert_last_imported_kit();

} catch ( \Error $error ) {
			\WP_CLI::error( $error->getMessage() );
		}

\WP_CLI::success( 'Kit reverted successfully.' );
	}

/**
	 * Helper to get kit url by the kit id
	 * TODO: Maybe extract it.
	 *
	 * @param $kit_id
	 *
	 * @return string
	 */
	private function get_url_from_library( $kit_id ) {
		/** @var Kit_Library $app */
		$app = Plugin::$instance->common->get_component( 'connect' )->get_app( 'kit-library' );

if ( ! $app ) {
			\WP_CLI::error( 'Kit library app not found' );
		}

$response = $app->download_link( $kit_id );

if ( is_wp_error( $response ) ) {
			\WP_CLI::error( "Library Response: {$response->get_error_message()}" );
		}

return $response->download_link;
	}

/**
	 * Helper to get kit zip file path by the kit url
	 * TODO: Maybe extract it.
	 *
	 * @param $url
	 *
	 * @return string
	 */
	private function create_temp_file_from_url( $url ) {
		\WP_CLI::line( 'Extracting zip archive...' );
		$response = wp_remote_get( $url );

if ( is_wp_error( $response ) ) {
			\WP_CLI::error( "Download file url: {$response->get_error_message()}" );
		}

if ( 200 !== $response['response']['code'] ) {
			\WP_CLI::error( "Download file url: {$response['response']['message']}" );
		}

// Set the Request's state as an Elementor upload request, in order to support unfiltered file uploads.
		Plugin::$instance->uploads_manager->set_elementor_upload_state( true );

$file = Plugin::$instance->uploads_manager->create_temp_file( $response['body'], 'kit.zip' );

// After the upload complete, set the elementor upload state back to false.
		Plugin::$instance->uploads_manager->set_elementor_upload_state( false );

return $file;
	}
}
PK������,�\��!�
��
��3��modules/import-export/runners/export/taxonomies.phpnu��[�����������<?php
namespace Elementor\App\Modules\ImportExport\Runners\Export;

use Elementor\App\Modules\ImportExport\Utils as ImportExportUtils;

class Taxonomies extends Export_Runner_Base {

public static function get_name(): string {
		return 'taxonomies';
	}

public function should_export( array $data ) {
		return (
			isset( $data['include'] ) &&
			in_array( 'content', $data['include'], true )
		);
	}

public function export( array $data ) {
		$wp_builtin_post_types = ImportExportUtils::get_builtin_wp_post_types();
		$selected_custom_post_types = isset( $data['selected_custom_post_types'] ) ? $data['selected_custom_post_types'] : [];
		$post_types = array_merge( $wp_builtin_post_types, $selected_custom_post_types );

$export = $this->export_taxonomies( $post_types );

$manifest_data['taxonomies'] = $export['manifest'];

return [
			'files' => $export['files'],
			'manifest' => [
				$manifest_data,
			],
		];
	}

private function export_taxonomies( array $post_types ) {
		$files = [];
		$manifest = [];

$taxonomies = get_taxonomies();

foreach ( $taxonomies as $taxonomy ) {
			$taxonomy_post_types = get_taxonomy( $taxonomy )->object_type;
			$intersected_post_types = array_intersect( $taxonomy_post_types, $post_types );

if ( empty( $intersected_post_types ) ) {
				continue;
			}

$data = $this->export_terms( $taxonomy );

if ( empty( $data ) ) {
				continue;
			}

foreach ( $intersected_post_types as $post_type ) {
				$manifest[ $post_type ][] = $taxonomy;
			}

$files[] = [
				'path' => 'taxonomies/' . $taxonomy,
				'data' => $data,
			];
		}

return [
			'files' => $files,
			'manifest' => $manifest,
		];
	}

private function export_terms( $taxonomy ) {
		$terms = get_terms( [
			'taxonomy' => (array) $taxonomy,
			'hide_empty' => true,
			'get' => 'all',
		] );

$ordered_terms = $this->order_terms( $terms );

if ( empty( $ordered_terms ) ) {
			return [];
		}

$data = [];

foreach ( $ordered_terms as $term ) {
			$data[] = [
				'term_id' => $term->term_id,
				'name' => $term->name,
				'slug' => $term->slug,
				'taxonomy' => $term->taxonomy,
				'description' => $term->description,
				'parent' => $term->parent,
			];
		}

return $data;
	}
	/**
	 * Put terms in order with no child going before its parent.
	 */
	private function order_terms( array $terms ) {
		$ordered_terms = [];

while ( $term = array_shift( $terms ) ) {
			$is_top_level = 0 === $term->parent;
			$is_parent_exits = isset( $ordered_terms[ $term->parent ] );

if ( $is_top_level || $is_parent_exits ) {
				$ordered_terms[ $term->term_id ] = $term;
			} else {
				$terms[] = $term;
			}
		}

return $ordered_terms;
	}
}
PK������,�\�r�������;��modules/import-export/runners/export/export-runner-base.phpnu��[�����������<?php

namespace Elementor\App\Modules\ImportExport\Runners\Export;

use Elementor\App\Modules\ImportExport\Runners\Runner_Interface;

abstract class Export_Runner_Base implements Runner_Interface {

/**
	 * By the passed data we should decide if we want to run the export function of the runner or not.
	 *
	 * @param array $data
	 *
	 * @return bool
	 */
	abstract public function should_export( array $data );

/**
	 * Main function of the runner export process.
	 *
	 * @param array $data Necessary data for the export process.
	 *
	 * @return array{files: array, manifest: array}
	 * The files that should be part of the kit and the relevant manifest data.
	 */
	abstract public function export( array $data );
}
PK������,�\~{�7.��.��0��modules/import-export/runners/export/plugins.phpnu��[�����������<?php

namespace Elementor\App\Modules\ImportExport\Runners\Export;

class Plugins extends Export_Runner_Base {

public static function get_name(): string {
		return 'plugins';
	}

public function should_export( array $data ) {
		return (
			isset( $data['include'] ) &&
			in_array( 'plugins', $data['include'], true ) &&
			is_array( $data['selected_plugins'] )
		);
	}

public function export( array $data ) {
		$manifest_data['plugins'] = $data['selected_plugins'];

return [
			'manifest' => [
				$manifest_data,
			],
			'files' => [],
		];
	}
}
PK������,�\!c�������:��modules/import-export/runners/export/elementor-content.phpnu��[�����������<?php

namespace Elementor\App\Modules\ImportExport\Runners\Export;

use Elementor\App\Modules\ImportExport\Utils as ImportExportUtils;
use Elementor\Plugin;

class Elementor_Content extends Export_Runner_Base {
	private $page_on_front_id;

public function __construct() {
		$this->init_page_on_front_data();
	}

public static function get_name(): string {
		return 'elementor-content';
	}

public function should_export( array $data ) {
		return (
			isset( $data['include'] ) &&
			in_array( 'content', $data['include'], true )
		);
	}

public function export( array $data ) {
		$elementor_post_types = ImportExportUtils::get_elementor_post_types();

$files = [];
		$manifest = [];

foreach ( $elementor_post_types as $post_type ) {
			$export = $this->export_elementor_post_type( $post_type );
			$files = array_merge( $files, $export['files'] );

$manifest[ $post_type ] = $export['manifest_data'];
		}

$manifest_data['content'] = $manifest;

return [
			'files' => $files,
			'manifest' => [
				$manifest_data,
			],
		];
	}

private function export_elementor_post_type( $post_type ) {
		$query_args = [
			'post_type' => $post_type,
			'post_status' => 'publish',
			'posts_per_page' => -1,
			'meta_query' => [
				[
					'key' => static::META_KEY_ELEMENTOR_EDIT_MODE,
					'compare' => 'EXISTS',
				],
				[
					'key' => '_elementor_data',
					'compare' => 'EXISTS',
				],
				[
					'key' => '_elementor_data',
					'compare' => '!=',
					'value' => '[]',
				],
			],
		];

$query = new \WP_Query( $query_args );

if ( empty( $query ) ) {
			return [
				'files' => [],
				'manifest_data' => [],
			];
		}

$post_type_taxonomies = $this->get_post_type_taxonomies( $post_type );

$manifest_data = [];
		$files = [];

foreach ( $query->posts as $post ) {
			$document = Plugin::$instance->documents->get( $post->ID );

$terms = ! empty( $post_type_taxonomies ) ? $this->get_post_terms( $post->ID, $post_type_taxonomies ) : [];

$post_manifest_data = [
				'title' => $post->post_title,
				'excerpt' => $post->post_excerpt,
				'doc_type' => $document->get_name(),
				'thumbnail' => get_the_post_thumbnail_url( $post ),
				'url' => get_permalink( $post ),
				'terms' => $terms,
			];

if ( $post->ID === $this->page_on_front_id ) {
				$post_manifest_data['show_on_front'] = true;
			}

$manifest_data[ $post->ID ] = $post_manifest_data;

$files[] = [
				'path' => 'content/' . $post_type . '/' . $post->ID,
				'data' => $document->get_export_data(),
			];
		}

return [
			'files' => $files,
			'manifest_data' => $manifest_data,
		];
	}

private function get_post_type_taxonomies( $post_type ) {
		return get_object_taxonomies( $post_type );
	}

private function get_post_terms( $post_id, array $taxonomies ) {
		$terms = wp_get_object_terms( $post_id, $taxonomies );

$result = [];

foreach ( $terms as $term ) {
			$result[] = [
				'term_id' => $term->term_id,
				'taxonomy' => $term->taxonomy,
				'slug' => $term->slug,
			];
		}

return $result;
	}

private function init_page_on_front_data() {
		$show_page_on_front = 'page' === get_option( 'show_on_front' );

if ( $show_page_on_front ) {
			$this->page_on_front_id = (int) get_option( 'page_on_front' );
		}
	}
}
PK������,�\��1	��	��6��modules/import-export/runners/export/site-settings.phpnu��[�����������<?php
namespace Elementor\App\Modules\ImportExport\Runners\Export;

use Elementor\Plugin;

class Site_Settings extends Export_Runner_Base {

public static function get_name(): string {
		return 'site-settings';
	}

public function should_export( array $data ) {
		return (
			isset( $data['include'] ) &&
			in_array( 'settings', $data['include'], true )
		);
	}

public function export( array $data ) {
		$kit = Plugin::$instance->kits_manager->get_active_kit();
		$kit_data = $kit->get_export_data();
		$kit_tabs = $kit->get_tabs();

$excluded_kit_settings_keys = [
			'site_name',
			'site_description',
			'site_logo',
			'site_favicon',
		];

foreach ( $excluded_kit_settings_keys as $setting_key ) {
			unset( $kit_data['settings'][ $setting_key ] );
		}

unset( $kit_tabs['settings-site-identity'] );

$kit_tabs = array_keys( $kit_tabs );

$theme_data = $this->export_theme();

if ( $theme_data ) {
			$kit_data['theme'] = $theme_data;
			$manifest_data['theme'] = $theme_data;
		}

$experiments_data = $this->export_experiments();

if ( $experiments_data ) {
			$kit_data['experiments'] = $experiments_data;
			$manifest_data['experiments'] = array_keys( $experiments_data );
		}

$manifest_data['site-settings'] = $kit_tabs;

return [
			'files' => [
				'path' => 'site-settings',
				'data' => $kit_data,
			],
			'manifest' => [
				$manifest_data,
			],
		];
	}

public function export_theme() {
		$theme = wp_get_theme();

if ( empty( $theme ) || empty( $theme->get( 'ThemeURI' ) ) ) {
			return null;
		}

$theme_data['name'] = $theme->get( 'Name' );
		$theme_data['theme_uri'] = $theme->get( 'ThemeURI' );
		$theme_data['version'] = $theme->get( 'Version' );
		$theme_data['slug'] = $theme->get_stylesheet();

return $theme_data;
	}

private function export_experiments() {
		$features = Plugin::$instance->experiments->get_features();

if ( empty( $features ) ) {
			return null;
		}

$experiments_data = [];

foreach ( $features as $feature_name => $feature ) {
			$experiments_data[ $feature_name ] = [
				'name' => $feature_name,
				'title' => $feature['title'],
				'state' => $feature['state'],
				'default' => $feature['default'],
				'release_status' => $feature['release_status'],
			];
		}

return empty( $experiments_data ) ? null : $experiments_data;
	}
}
PK������,�\�j�s������2��modules/import-export/runners/export/templates.phpnu��[�����������<?php

namespace Elementor\App\Modules\ImportExport\Runners\Export;

use Elementor\Core\Base\Document;
use Elementor\Plugin;
use Elementor\TemplateLibrary\Source_Local;
use Elementor\Utils;

class Templates extends Export_Runner_Base {

public static function get_name(): string {
		return 'templates';
	}

public function should_export( array $data ) {
		return (
			Utils::has_pro() &&
			isset( $data['include'] ) &&
			in_array( 'templates', $data['include'], true )
		);
	}

public function export( array $data ) {
		$template_types = array_values( Source_Local::get_template_types() );

$query_args = [
			'post_type' => Source_Local::CPT,
			'post_status' => 'publish',
			'posts_per_page' => -1,
			'meta_query' => [
				[
					'key' => Document::TYPE_META_KEY,
					'value' => $template_types,
				],
			],
		];

$templates_query = new \WP_Query( $query_args );

$templates_manifest_data = [];
		$files = [];

foreach ( $templates_query->posts as $template_post ) {
			$template_id = $template_post->ID;

$template_document = Plugin::$instance->documents->get( $template_id );

$templates_manifest_data[ $template_id ] = $template_document->get_export_summary();

$files[] = [
				'path' => 'templates/' . $template_id,
				'data' => $template_document->get_export_data(),
			];
		}

$manifest_data['templates'] = $templates_manifest_data;

return [
			'files' => $files,
			'manifest' => [
				$manifest_data,
			],
		];
	}
}
PK������,�\�u�������3��modules/import-export/runners/export/wp-content.phpnu��[�����������<?php

namespace Elementor\App\Modules\ImportExport\Runners\Export;

use Elementor\App\Modules\ImportExport\Utils as ImportExportUtils;
use Elementor\Core\Utils\ImportExport\WP_Exporter;

class Wp_Content extends Export_Runner_Base {

public static function get_name(): string {
		return 'wp-content';
	}

public function should_export( array $data ) {
		return (
			isset( $data['include'] ) &&
			in_array( 'content', $data['include'], true )
		);
	}

public function export( array $data ) {
		$post_types = ImportExportUtils::get_builtin_wp_post_types();
		$custom_post_types = isset( $data['selected_custom_post_types'] ) ? $data['selected_custom_post_types'] : [];

$files = [];
		$manifest_data = [];

foreach ( $post_types as $post_type ) {
			$export = $this->export_wp_post_type( $post_type );
			$files[] = $export['file'];
			$manifest_data['wp-content'][ $post_type ] = $export['manifest_data'];
		}

foreach ( $custom_post_types as $post_type ) {
			$export = $this->export_wp_post_type( $post_type );
			$files[] = $export['file'];
			$manifest_data['wp-content'][ $post_type ] = $export['manifest_data'];

$post_type_object = get_post_type_object( $post_type );

$manifest_data['custom-post-type-title'][ $post_type ] = [
				'name' => $post_type_object->name,
				'label' => $post_type_object->label,
			];
		}

return [
			'files' => $files,
			'manifest' => [
				$manifest_data,
			],
		];
	}

private function export_wp_post_type( $post_type ) {
		$wp_exporter = new WP_Exporter( [
			'content' => $post_type,
			'status' => 'publish',
			'limit' => 20,
			'meta_query' => [
				[
					'key' => static::META_KEY_ELEMENTOR_EDIT_MODE,
					'compare' => 'NOT EXISTS',
				],
			],
			'include_post_featured_image_as_attachment' => true,
		] );

$export_result = $wp_exporter->run();

return [
			'file' => [
				'path' => 'wp-content/' . $post_type . '/' . $post_type . '.xml',
				'data' => $export_result['xml'],
			],
			'manifest_data' => $export_result['ids'],
		];
	}
}
PK������,�\y�D����2��modules/import-export/runners/runner-interface.phpnu��[�����������<?php

namespace Elementor\App\Modules\ImportExport\Runners;

use Elementor\App\Modules\ImportExport\Module;

interface Runner_Interface {

const META_KEY_ELEMENTOR_IMPORT_SESSION_ID = Module::META_KEY_ELEMENTOR_IMPORT_SESSION_ID;

const META_KEY_ELEMENTOR_EDIT_MODE = Module::META_KEY_ELEMENTOR_EDIT_MODE;

/**
	 * Get the name of the runners, used to identify the runner.
	 * The name should be unique, unless you want to run over existing runner.
	 *
	 * @return string
	 */
	public static function get_name(): string;
}
PK������,�\0��x����3��modules/import-export/runners/revert/taxonomies.phpnu��[�����������<?php

namespace Elementor\App\Modules\ImportExport\Runners\Revert;

class Taxonomies extends Revert_Runner_Base {

public static function get_name(): string {
		return 'taxonomies';
	}

public function should_revert( array $data ): bool {
		return (
			isset( $data['runners'] ) &&
			array_key_exists( static::get_name(), $data['runners'] )
		);
	}

public function revert( array $data ) {
		$taxonomies = get_taxonomies();

$terms = get_terms( [
			'taxonomy' => $taxonomies,
			'hide_empty' => false,
			'get' => 'all',
			'meta_query' => [
				[
					'key'       => static::META_KEY_ELEMENTOR_IMPORT_SESSION_ID,
					'value'     => $data['session_id'],
				],
			],
		] );

foreach ( $terms as $term ) {
			wp_delete_term( $term->term_id, $term->taxonomy );
		}
	}
}
PK������,�\��yT��T��;��modules/import-export/runners/revert/revert-runner-base.phpnu��[�����������<?php

namespace Elementor\App\Modules\ImportExport\Runners\Revert;

use Elementor\App\Modules\ImportExport\Runners\Runner_Interface;

abstract class Revert_Runner_Base implements Runner_Interface {

/**
	 * By the passed data we should decide if we want to run the revert function of the runner or not.
	 *
	 * @param array $data
	 *
	 * @return bool
	 */
	abstract public function should_revert( array $data ): bool;

/**
	 * Main function of the runner revert process.
	 *
	 * @param array $data Necessary data for the revert process.
	 */
	abstract public function revert( array $data );
}
PK������,�\���,��,��0��modules/import-export/runners/revert/plugins.phpnu��[�����������<?php

namespace Elementor\App\Modules\ImportExport\Runners\Revert;

class Plugins extends Revert_Runner_Base {

public static function get_name(): string {
		return 'plugins';
	}

public function should_revert( array $data ): bool {
		return false;
	}

public function revert( array $data ) {}
}
PK������,�\
�!t	��	��:��modules/import-export/runners/revert/elementor-content.phpnu��[�����������<?php

namespace Elementor\App\Modules\ImportExport\Runners\Revert;

use Elementor\App\Modules\ImportExport\Utils as ImportExportUtils;
use Elementor\Plugin;

class Elementor_Content extends Revert_Runner_Base {
	private $show_page_on_front;

private $page_on_front_id;

public function __construct() {
		$this->init_page_on_front_data();
	}

public static function get_name(): string {
		return 'elementor-content';
	}

public function should_revert( array $data ): bool {
		return (
			isset( $data['runners'] ) &&
			array_key_exists( static::get_name(), $data['runners'] )
		);
	}

public function revert( array $data ) {
		$elementor_post_types = ImportExportUtils::get_elementor_post_types();

$query_args = [
			'post_type' => $elementor_post_types,
			'post_status' => 'any',
			'posts_per_page' => -1,
			'meta_query' => [
				[
					'key' => static::META_KEY_ELEMENTOR_EDIT_MODE,
					'compare' => 'EXISTS',
				],
				[
					'key' => static::META_KEY_ELEMENTOR_IMPORT_SESSION_ID,
					'value' => $data['session_id'],
				],
			],
		];

$query = new \WP_Query( $query_args );

foreach ( $query->posts as $post ) {
			$post_type_document = Plugin::$instance->documents->get( $post->ID );
			$post_type_document->delete();

// Deleting the post will reset the show_on_front option. We need to set it to false,
			// so we can set it back to what it was.
			if ( $post->ID === $this->page_on_front_id ) {
				$this->show_page_on_front = false;
			}
		}

$this->restore_page_on_front( $data );
	}

private function init_page_on_front_data() {
		$this->show_page_on_front = 'page' === get_option( 'show_on_front' );

if ( $this->show_page_on_front ) {
			$this->page_on_front_id = (int) get_option( 'page_on_front' );
		}
	}

private function restore_page_on_front( $data ) {
		if ( empty( $data['runners'][ static::get_name() ]['page_on_front'] ) ) {
			return;
		}

$page_on_front = $data['runners'][ static::get_name() ]['page_on_front'];

$document = Plugin::$instance->documents->get( $page_on_front );

if ( ! $document ) {
			return;
		}

$this->set_page_on_front( $document->get_main_id() );
	}

private function set_page_on_front( $page_id ) {
		update_option( 'page_on_front', $page_id );

if ( ! $this->show_page_on_front ) {
			update_option( 'show_on_front', 'page' );
		}
	}
}
PK������,�\-�w{������6��modules/import-export/runners/revert/site-settings.phpnu��[�����������<?php

namespace Elementor\App\Modules\ImportExport\Runners\Revert;

use Elementor\Plugin;
use Elementor\Core\Experiments\Manager as ExperimentsManager;

class Site_Settings extends Revert_Runner_Base {

public static function get_name(): string {
		return 'site-settings';
	}

public function should_revert( array $data ): bool {
		return (
			isset( $data['runners'] ) &&
			array_key_exists( static::get_name(), $data['runners'] )
		);
	}

public function revert( array $data ) {
		Plugin::$instance->kits_manager->revert(
			$data['runners'][ static::get_name() ]['imported_kit_id'],
			$data['runners'][ static::get_name() ]['active_kit_id'],
			$data['runners'][ static::get_name() ]['previous_kit_id']
		);

$this->revert_theme( $data );
		$this->revert_experiments( $data );
	}

public function get_theme_upgrader(): \Theme_Upgrader {
		if ( ! class_exists( '\Theme_Upgrader' ) ) {
			require_once ABSPATH . 'wp-admin/includes/class-wp-upgrader.php';
		}

if ( ! class_exists( '\WP_Ajax_Upgrader_Skin' ) ) {
			require_once ABSPATH . 'wp-admin/includes/class-wp-ajax-upgrader-skin.php';
		}

return new \Theme_Upgrader( new \WP_Ajax_Upgrader_Skin() );
	}

protected function revert_theme( $data ) {
		$installed_theme = $data['runners'][ static::get_name() ]['installed_theme'];
		$activated_theme = $data['runners'][ static::get_name() ]['activated_theme'];
		$previous_active_theme = $data['runners'][ static::get_name() ]['previous_active_theme'];

if ( empty( $installed_theme ) && empty( $activated_theme ) ) {
			// no need to remove a theme as it was used before import
			return;
		}

if ( ! empty( $activated_theme ) ) {
			$previous_theme = wp_get_theme( $previous_active_theme['slug'] );

// no need to remove imported theme as it existed before import
			$this->activate_previous_theme( $previous_active_theme );
			return;
		}

if ( ! empty( $installed_theme ) ) {
			$this->activate_previous_theme( $previous_active_theme );
			$this->delete_theme( $installed_theme );
		}
	}

protected function should_delete_theme( $theme_slug ): bool {
		$current_theme = wp_get_theme();

return $theme_slug !== $current_theme->get_stylesheet() && wp_get_theme( $theme_slug )->exists();
	}

protected function delete_theme( $theme_slug ): bool {
		return delete_theme( $theme_slug );
	}

protected function activate_previous_theme( $previous_active_theme ) {
		if ( ! $previous_active_theme ) {
			return;
		}

$theme = wp_get_theme( $previous_active_theme['slug'] );

if ( $theme->exists() ) {
			switch_theme( $theme->get_stylesheet() );
			return;
		}

$download_url = "https://downloads.wordpress.org/theme/{$previous_active_theme['slug']}.{$previous_active_theme['version']}.zip";
		$install = $this->get_theme_upgrader()->install( $download_url );

if ( ! $install || is_wp_error( $install ) ) {
			return;
		}

switch_theme( $previous_active_theme['slug'] );
	}

protected function revert_experiments( array $data ) {
		$runner_data = $data['runners'][ static::get_name() ];
		$previous_experiments = $runner_data['previous_experiments'] ?? [];

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

$experiments_manager = Plugin::$instance->experiments;
		$current_features = $experiments_manager->get_features();

foreach ( $previous_experiments as $feature_name => $feature_data ) {
			if ( ! isset( $current_features[ $feature_name ] ) ) {
				continue;
			}

if ( ! array_key_exists( $feature_name, $previous_experiments ) ) {
				continue;
			}

$option_key = $experiments_manager->get_feature_option_key( $feature_name );
			$previous_state = $feature_data['state'];

if ( ExperimentsManager::STATE_DEFAULT === $previous_state ) {
				delete_option( $option_key );
			} else {
				update_option( $option_key, $previous_state );
			}
		}
	}
}
PK������,�\P��Lv��v��2��modules/import-export/runners/revert/templates.phpnu��[�����������<?php

namespace Elementor\App\Modules\ImportExport\Runners\Revert;

class Templates extends Revert_Runner_Base {
	/**
	 * The implement of this runner is part of the Pro plugin.
	 */
	public static function get_name(): string {
		return 'templates';
	}

public function should_revert( array $data ): bool {
		return false;
	}

public function revert( array $data ) { }
}
PK������,�\�P$:����3��modules/import-export/runners/revert/wp-content.phpnu��[�����������<?php

namespace Elementor\App\Modules\ImportExport\Runners\Revert;

use Elementor\App\Modules\ImportExport\Utils as ImportExportUtils;

class Wp_Content extends Revert_Runner_Base {

public static function get_name(): string {
		return 'wp-content';
	}

public function should_revert( array $data ): bool {
		return (
			isset( $data['runners'] ) &&
			array_key_exists( static::get_name(), $data['runners'] )
		);
	}

public function revert( array $data ) {
		$builtin_post_types = ImportExportUtils::get_builtin_wp_post_types();
		$custom_post_types = $data['runners']['wp-content']['custom_post_types'] ?? [];

$post_types = array_merge( $builtin_post_types, $custom_post_types );

$query_args = [
			'post_type' => $post_types,
			'post_status' => 'any',
			'posts_per_page' => -1,
			'meta_query' => [
				[
					'key' => static::META_KEY_ELEMENTOR_EDIT_MODE,
					'compare' => 'NOT EXISTS',
				],
				[
					'key' => static::META_KEY_ELEMENTOR_IMPORT_SESSION_ID,
					'value' => $data['session_id'],
				],
			],
		];

$query = new \WP_Query( $query_args );

foreach ( $query->posts as $post ) {
			wp_delete_post( $post->ID, true );
		}

/**
		 * Revert the nav menu terms.
		 * BC: The nav menu in new kits will be imported as part of the taxonomies, but old kits
		 * importing the nav menu terms as part from the wp-content import.
		 */
		$this->revert_nav_menus( $data );
	}

private function revert_nav_menus( array $data ) {
		$terms = get_terms( [
			'taxonomy' => 'nav_menu',
			'hide_empty' => false,
			'get' => 'all',
			'meta_query' => [
				[
					'key'       => static::META_KEY_ELEMENTOR_IMPORT_SESSION_ID,
					'value'     => $data['session_id'],
				],
			],
		] );

foreach ( $terms as $term ) {
			wp_delete_term( $term->term_id, $term->taxonomy );
		}
	}
}
PK������,�\u��?������3��modules/import-export/runners/import/taxonomies.phpnu��[�����������<?php

namespace Elementor\App\Modules\ImportExport\Runners\Import;

use Elementor\App\Modules\ImportExport\Utils as ImportExportUtils;

class Taxonomies extends Import_Runner_Base {

private $import_session_id;

public static function get_name(): string {
		return 'taxonomies';
	}

public function should_import( array $data ) {
		return (
			isset( $data['include'] ) &&
			in_array( 'content', $data['include'], true ) &&
			! empty( $data['extracted_directory_path'] ) &&
			! empty( $data['manifest']['taxonomies'] )
		);
	}

public function import( array $data, array $imported_data ) {
		$path = $data['extracted_directory_path'] . 'taxonomies/';
		$this->import_session_id = $data['session_id'];

$wp_builtin_post_types = ImportExportUtils::get_builtin_wp_post_types();
		$selected_custom_post_types = isset( $data['selected_custom_post_types'] ) ? $data['selected_custom_post_types'] : [];
		$post_types = array_merge( $wp_builtin_post_types, $selected_custom_post_types );

$result = [];

foreach ( $post_types as $post_type ) {
			if ( empty( $data['manifest']['taxonomies'][ $post_type ] ) ) {
				continue;
			}

$result['taxonomies'][ $post_type ] = $this->import_taxonomies( $data['manifest']['taxonomies'][ $post_type ], $path );
		}

return $result;
	}

private function import_taxonomies( array $taxonomies, $path ) {
		$result = [];
		$imported_taxonomies = [];

foreach ( $taxonomies as $taxonomy ) {
			if ( ! taxonomy_exists( $taxonomy ) ) {
				continue;
			}

if ( ! empty( $imported_taxonomies[ $taxonomy ] ) ) {
				$result[ $taxonomy ] = $imported_taxonomies[ $taxonomy ];
				continue;
			}

$taxonomy_data = ImportExportUtils::read_json_file( $path . $taxonomy );
			if ( empty( $taxonomy_data ) ) {
				continue;
			}

$import = $this->import_taxonomy( $taxonomy_data );
			$result[ $taxonomy ] = $import;
			$imported_taxonomies[ $taxonomy ] = $import;
		}

return $result;
	}

private function import_taxonomy( array $taxonomy_data ) {
		$terms = [];

foreach ( $taxonomy_data as $term ) {
			$old_slug = $term['slug'];

$existing_term = term_exists( $term['slug'], $term['taxonomy'] );
			if ( $existing_term ) {
				if ( 'nav_menu' === $term['taxonomy'] ) {
					$term = $this->handle_duplicated_nav_menu_term( $term );
				} else {
					$terms[] = [
						'old_id' => (int) $term['term_id'],
						'new_id' => (int) $existing_term['term_id'],
						'old_slug' => $old_slug,
						'new_slug' => $term['slug'],
					];
					continue;
				}
			}

$parent = $this->get_term_parent( $term, $terms );

$args = [
				'slug' => $term['slug'],
				'description' => wp_slash( $term['description'] ),
				'parent' => (int) $parent,
			];

$new_term = wp_insert_term( wp_slash( $term['name'] ), $term['taxonomy'], $args );
			if ( ! is_wp_error( $new_term ) ) {
				$this->set_session_term_meta( (int) $new_term['term_id'], $this->import_session_id );

$terms[] = [
					'old_id' => $term['term_id'],
					'new_id' => (int) $new_term['term_id'],
					'old_slug' => $old_slug,
					'new_slug' => $term['slug'],
				];
			}
		}

return $terms;
	}

private function handle_duplicated_nav_menu_term( $term ) {
		do {
			$term['slug'] = $term['slug'] . '-duplicate';
			$term['name'] = $term['name'] . ' duplicate';
		} while ( term_exists( $term['slug'], 'nav_menu' ) );

return $term;
	}

private function get_term_parent( $term, array $imported_terms ) {
		$parent = $term['parent'];
		if ( 0 !== $parent && ! empty( $imported_terms ) ) {
			foreach ( $imported_terms as $imported_term ) {
				if ( $parent === $imported_term['old_id'] ) {
					$parent_term = term_exists( $imported_term['new_id'], $term['taxonomy'] );
					break;
				}
			}

if ( isset( $parent_term['term_id'] ) ) {
				return $parent_term['term_id'];
			}
		}

return 0;
	}
}
PK������,�\�(і�����0��modules/import-export/runners/import/plugins.phpnu��[�����������<?php

namespace Elementor\App\Modules\ImportExport\Runners\Import;

use Elementor\Core\Utils\Collection;
use Elementor\Core\Utils\Plugins_Manager;
use Elementor\Core\Utils\Str;

class Plugins extends Import_Runner_Base {

/**
	 * @var Plugins_Manager
	 */
	private $plugins_manager;

public function __construct( $plugins_manager = null ) {
		if ( $plugins_manager ) {
			$this->plugins_manager = $plugins_manager;
		} else {
			$this->plugins_manager = new Plugins_Manager();
		}
	}

public static function get_name(): string {
		return 'plugins';
	}

public function should_import( array $data ) {
		return (
			isset( $data['include'] ) &&
			in_array( 'plugins', $data['include'], true ) &&
			! empty( $data['manifest']['plugins'] ) &&
			! empty( $data['selected_plugins'] )
		);
	}

public function import( array $data, array $imported_data ) {
		$plugins = $data['selected_plugins'];

$plugins_collection = ( new Collection( $plugins ) )
			->map( function ( $item ) {
				if ( ! Str::ends_with( $item['plugin'], '.php' ) ) {
					$item['plugin'] .= '.php';
				}
				return $item;
			} );

$slugs = $plugins_collection
			->map( function ( $item ) {
				return $item['plugin'];
			} )
			->all();

$installed = $this->plugins_manager->install( $slugs );
		$activated = $this->plugins_manager->activate( $installed['succeeded'] );

$ordered_activated_plugins = $plugins_collection
			->filter( function ( $item ) use ( $activated ) {
				return in_array( $item['plugin'], $activated['succeeded'], true );
			} )
			->map( function ( $item ) {
				return $item['name'];
			} )
			->all();

$result['plugins'] = $ordered_activated_plugins;

return $result;
	}
}
PK������,�\��`�X��X��:��modules/import-export/runners/import/elementor-content.phpnu��[�����������<?php
namespace Elementor\App\Modules\ImportExport\Runners\Import;

use Elementor\App\Modules\ImportExport\Utils as ImportExportUtils;
use Elementor\Plugin;

class Elementor_Content extends Import_Runner_Base {

private $show_page_on_front;

private $page_on_front_id;

private $import_session_id;

public function __construct() {
		$this->init_page_on_front_data();
	}

public static function get_name(): string {
		return 'elementor-content';
	}

public function should_import( array $data ) {
		return (
			isset( $data['include'] ) &&
			in_array( 'content', $data['include'], true ) &&
			! empty( $data['manifest']['content'] ) &&
			! empty( $data['extracted_directory_path'] )
		);
	}

public function import( array $data, array $imported_data ) {
		$result['content'] = [];
		$this->import_session_id = $data['session_id'];

$elementor_post_types = ImportExportUtils::get_elementor_post_types();

foreach ( $elementor_post_types as $post_type ) {
			if ( empty( $data['manifest']['content'][ $post_type ] ) ) {
				continue;
			}

$posts_settings = $data['manifest']['content'][ $post_type ];
			$path = $data['extracted_directory_path'] . 'content/' . $post_type . '/';
			$imported_terms = ! empty( $imported_data['taxonomies'] )
				? ImportExportUtils::map_old_new_term_ids( $imported_data )
				: [];

$result['content'][ $post_type ] = $this->import_elementor_post_type( $posts_settings, $path, $post_type, $imported_terms );
		}

return $result;
	}

private function import_elementor_post_type( array $posts_settings, $path, $post_type, array $imported_terms ) {
		$result = [
			'succeed' => [],
			'failed' => [],
		];

foreach ( $posts_settings as $id => $post_settings ) {
			try {
				$post_data = ImportExportUtils::read_json_file( $path . $id );
				$import = $this->import_post( $post_settings, $post_data, $post_type, $imported_terms );

if ( is_wp_error( $import ) ) {
					$result['failed'][ $id ] = $import->get_error_message();
					continue;
				}

$result['succeed'][ $id ] = $import;
			} catch ( \Exception $error ) {
				$result['failed'][ $id ] = $error->getMessage();
			}
		}

return $result;
	}

private function import_post( array $post_settings, array $post_data, $post_type, array $imported_terms ) {
		$post_attributes = [
			'post_title' => $post_settings['title'],
			'post_type' => $post_type,
			'post_status' => 'publish',
		];

if ( ! empty( $post_settings['excerpt'] ) ) {
			$post_attributes['post_excerpt'] = $post_settings['excerpt'];
		}

$new_document = Plugin::$instance->documents->create(
			$post_settings['doc_type'],
			$post_attributes
		);

if ( is_wp_error( $new_document ) ) {
			throw new \Exception( esc_html( $new_document->get_error_message() ) );
		}

$post_data['import_settings'] = $post_settings;

$new_attachment_callback = function( $attachment_id ) {
			$this->set_session_post_meta( $attachment_id, $this->import_session_id );
		};

add_filter( 'elementor/template_library/import_images/new_attachment', $new_attachment_callback );

$new_document->import( $post_data );

remove_filter( 'elementor/template_library/import_images/new_attachment', $new_attachment_callback );

$new_post_id = $new_document->get_main_id();

if ( ! empty( $post_settings['terms'] ) ) {
			$this->set_post_terms( $new_post_id, $post_settings['terms'], $imported_terms );
		}

if ( ! empty( $post_settings['show_on_front'] ) ) {
			$this->set_page_on_front( $new_post_id );
		}

$this->set_session_post_meta( $new_post_id, $this->import_session_id );

return $new_post_id;
	}

private function set_post_terms( $post_id, array $terms, array $imported_terms ) {
		foreach ( $terms as $term ) {
			if ( ! isset( $imported_terms[ $term['term_id'] ] ) ) {
				continue;
			}

wp_set_post_terms( $post_id, [ $imported_terms[ $term['term_id'] ] ], $term['taxonomy'], false );
		}
	}

private function init_page_on_front_data() {
		$this->show_page_on_front = 'page' === get_option( 'show_on_front' );

if ( $this->show_page_on_front ) {
			$this->page_on_front_id = (int) get_option( 'page_on_front' );
		}
	}

private function set_page_on_front( $page_id ) {
		update_option( 'page_on_front', $page_id );

if ( ! $this->show_page_on_front ) {
			update_option( 'show_on_front', 'page' );
		}
	}

public function get_import_session_metadata(): array {
		return [
			'page_on_front' => $this->page_on_front_id ?? 0,
		];
	}
}
PK������,�\�B������6��modules/import-export/runners/import/site-settings.phpnu��[�����������<?php

namespace Elementor\App\Modules\ImportExport\Runners\Import;

use Elementor\Plugin;
use Elementor\Core\Settings\Page\Manager as PageManager;
use Elementor\App\Modules\ImportExport\Utils;
use Elementor\Core\Experiments\Manager as ExperimentsManager;

class Site_Settings extends Import_Runner_Base {

/**
	 * @var int
	 */
	private $previous_kit_id;

/**
	 * @var int
	 */
	private $active_kit_id;

/**
	 * @var int
	 */
	private $imported_kit_id;

/**
	 * @var string|null
	 */
	private ?string $installed_theme = null;

/**
	 * @var string|null
	 */
	private ?string $activated_theme = null;

/**
	 * @var array|null
	 */
	private ?array $previous_active_theme = null;

/**
	 * @var array
	 */
	private $previous_experiments = [];

/**
	 * @var array
	 */
	private $imported_experiments = [];

public function get_theme_upgrader(): \Theme_Upgrader {
		if ( ! class_exists( '\Theme_Upgrader' ) ) {
			require_once ABSPATH . 'wp-admin/includes/class-wp-upgrader.php';
		}

if ( ! class_exists( '\WP_Ajax_Upgrader_Skin' ) ) {
			require_once ABSPATH . 'wp-admin/includes/class-wp-ajax-upgrader-skin.php';
		}

return new \Theme_Upgrader( new \WP_Ajax_Upgrader_Skin() );
	}

public static function get_name(): string {
		return 'site-settings';
	}

public function should_import( array $data ) {
		return (
			isset( $data['include'] ) &&
			in_array( 'settings', $data['include'], true ) &&
			! empty( $data['site_settings']['settings'] )
		);
	}

public function import( array $data, array $imported_data ) {
		$new_site_settings = $data['site_settings']['settings'];
		$title = $data['manifest']['title'] ?? 'Imported Kit';

$active_kit = Plugin::$instance->kits_manager->get_active_kit();

$this->active_kit_id = (int) $active_kit->get_id();
		$this->previous_kit_id = (int) Plugin::$instance->kits_manager->get_previous_id();

$result = [];

$old_settings = $active_kit->get_meta( PageManager::META_KEY );

if ( ! $old_settings ) {
			$old_settings = [];
		}

if ( ! empty( $old_settings['custom_colors'] ) ) {
			$new_site_settings['custom_colors'] = array_merge( $old_settings['custom_colors'], $new_site_settings['custom_colors'] );
		}

if ( ! empty( $old_settings['custom_typography'] ) ) {
			$new_site_settings['custom_typography'] = array_merge( $old_settings['custom_typography'], $new_site_settings['custom_typography'] );
		}

if ( ! empty( $new_site_settings['space_between_widgets'] ) ) {
			$new_site_settings['space_between_widgets'] = Utils::update_space_between_widgets_values( $new_site_settings['space_between_widgets'] );
		}

$new_site_settings = array_replace_recursive( $old_settings, $new_site_settings );

$new_kit = Plugin::$instance->kits_manager->create_new_kit( $title, $new_site_settings );

$this->imported_kit_id = (int) $new_kit;

$result['site-settings'] = (bool) $new_kit;

$import_theme_result = $this->import_theme( $data );

if ( ! empty( $import_theme_result ) ) {
			$result['theme'] = $import_theme_result;
		}

$this->import_experiments( $data );

if ( ! empty( $this->imported_experiments ) ) {
			$result['experiments'] = $this->imported_experiments;
		}

return $result;
	}

protected function install_theme( $slug, $version ) {
		$download_url = "https://downloads.wordpress.org/theme/{$slug}.{$version}.zip";

return $this->get_theme_upgrader()->install( $download_url );
	}

protected function activate_theme( $slug ) {
		switch_theme( $slug );
	}

public function import_theme( array $data ) {
		if ( empty( $data['site_settings']['theme'] ) ) {
			return null;
		}

$theme = $data['site_settings']['theme'];
		$theme_slug = $theme['slug'];
		$theme_name = $theme['name'];

$current_theme = wp_get_theme();
		$this->previous_active_theme = [];
		$this->previous_active_theme['slug'] = $current_theme->get_stylesheet();
		$this->previous_active_theme['version'] = $current_theme->get( 'Version' );

if ( $current_theme->get_stylesheet() === $theme_slug ) {
			$result['succeed'][ $theme_slug ] = sprintf(
				/* translators: %s: Theme name. */
				__( 'Theme: %1$s is already used', 'elementor' ),
				$theme_name
			);
			return $result;
		}

try {
			if ( wp_get_theme( $theme_slug )->exists() ) {
				$this->activate_theme( $theme_slug );
				$this->activated_theme = $theme_slug;
				$result['succeed'][ $theme_slug ] = sprintf(
					/* translators: %s: Theme name. */
					__( 'Theme: %1$s has already been installed and activated', 'elementor' ),
					$theme_name
				);
				return $result;
			}

$import = $this->install_theme( $theme_slug, $theme['version'] );

if ( is_wp_error( $import ) ) {
				$result['failed'][ $theme_slug ] = sprintf(
					/* translators: %s: Theme name. */
					__( 'Failed to install theme: %1$s', 'elementor' ),
					$theme_name
				);
				return $result;
			}

$result['succeed'][ $theme_slug ] = sprintf(
				/* translators: %s: Theme name. */
				__( 'Theme: %1$s has been successfully installed', 'elementor' ),
				$theme_name
			);
			$this->installed_theme = $theme_slug;
			$this->activate_theme( $theme_slug );
		} catch ( \Exception $error ) {
			$result['failed'][ $theme_slug ] = $error->getMessage();
		}

return $result;
	}

private function import_experiments( array $data ) {
		if ( empty( $data['site_settings']['experiments'] ) ) {
			return null;
		}

$experiments_data = $data['site_settings']['experiments'];
		$experiments_manager = Plugin::$instance->experiments;
		$current_features = $experiments_manager->get_features();

$this->save_previous_experiments_state( $current_features );

foreach ( $experiments_data as $feature_name => $feature_data ) {
			if ( ! isset( $current_features[ $feature_name ] ) ) {
				continue;
			}

$current_feature = $current_features[ $feature_name ];

$current_feature_state = $current_feature['state'];
			$new_state = $feature_data['state'];

if ( $current_feature_state === $new_state ) {
				continue;
			}

if ( ! in_array( $new_state, [ ExperimentsManager::STATE_DEFAULT, ExperimentsManager::STATE_ACTIVE, ExperimentsManager::STATE_ACTIVE ], true ) ) {
				continue;
			}

$option_key = $experiments_manager->get_feature_option_key( $feature_name );

if ( 'default' === $new_state ) {
				delete_option( $option_key );
			} else {
				update_option( $option_key, $new_state );
			}

$this->imported_experiments[ $feature_name ] = $feature_data;
		}
	}

private function save_previous_experiments_state( array $current_features ) {
		$experiments_manager = Plugin::$instance->experiments;

foreach ( $current_features as $feature_name => $feature ) {
			if ( ! $feature['mutable'] ) {
				continue;
			}

$option_key = $experiments_manager->get_feature_option_key( $feature_name );
			$saved_state = get_option( $option_key );

$this->previous_experiments[ $feature_name ] = [
				'name' => $feature_name,
				'title' => $feature['title'],
				'state' => empty( $saved_state ) ? 'default' : $saved_state,
				'default' => $feature['default'],
				'release_status' => $feature['release_status'],
			];
		}
	}

public function get_import_session_metadata(): array {
		return [
			'previous_kit_id' => $this->previous_kit_id,
			'active_kit_id' => $this->active_kit_id,
			'imported_kit_id' => $this->imported_kit_id,
			'installed_theme' => $this->installed_theme,
			'activated_theme' => $this->activated_theme,
			'previous_active_theme' => $this->previous_active_theme,
			'previous_experiments' => $this->previous_experiments,
			'imported_experiments' => $this->imported_experiments,
		];
	}
}
PK������,�\��G�	���	��2��modules/import-export/runners/import/templates.phpnu��[�����������<?php
namespace Elementor\App\Modules\ImportExport\Runners\Import;

use Elementor\App\Modules\ImportExport\Utils as ImportExportUtils;
use Elementor\Plugin;
use Elementor\TemplateLibrary\Source_Local;
use Elementor\Utils;

class Templates extends Import_Runner_Base {
	private $import_session_id;

public static function get_name(): string {
		return 'templates';
	}

public function should_import( array $data ) {
		return (
			Utils::has_pro() &&
			isset( $data['include'] ) &&
			in_array( 'templates', $data['include'], true ) &&
			! empty( $data['extracted_directory_path'] ) &&
			! empty( $data['manifest']['templates'] )
		);
	}

public function import( array $data, array $imported_data ) {
		$this->import_session_id = $data['session_id'];

$path = $data['extracted_directory_path'] . 'templates/';
		$templates = $data['manifest']['templates'];

$result['templates'] = [
			'succeed' => [],
			'failed' => [],
		];

foreach ( $templates as $id => $template_settings ) {
			try {
				$template_data = ImportExportUtils::read_json_file( $path . $id );
				$import = $this->import_template( $id, $template_settings, $template_data );

$result['templates']['succeed'][ $id ] = $import;
			} catch ( \Exception $error ) {
				$result['templates']['failed'][ $id ] = $error->getMessage();
			}
		}

return $result;
	}

private function import_template( $id, array $template_settings, array $template_data ) {
		$doc_type = $template_settings['doc_type'];

$new_document = Plugin::$instance->documents->create(
			$doc_type,
			[
				'post_title' => $template_settings['title'],
				'post_type' => Source_Local::CPT,
				'post_status' => 'publish',
			]
		);

if ( is_wp_error( $new_document ) ) {
			throw new \Exception( esc_html( $new_document->get_error_message() ) );
		}

$template_data['import_settings'] = $template_settings;
		$template_data['id'] = $id;

$new_attachment_callback = function( $attachment_id ) {
			$this->set_session_post_meta( $attachment_id, $this->import_session_id );
		};

add_filter( 'elementor/template_library/import_images/new_attachment', $new_attachment_callback );

$new_document->import( $template_data );

remove_filter( 'elementor/template_library/import_images/new_attachment', $new_attachment_callback );

$document_id = $new_document->get_main_id();

$this->set_session_post_meta( $document_id, $this->import_session_id );

return $document_id;
	}
}
PK������,�\�v�rH
��H
��3��modules/import-export/runners/import/wp-content.phpnu��[�����������<?php

namespace Elementor\App\Modules\ImportExport\Runners\Import;

use Elementor\App\Modules\ImportExport\Utils as ImportExportUtils;
use Elementor\Core\Utils\ImportExport\WP_Import;

class Wp_Content extends Import_Runner_Base {

private $import_session_id;

/**
	 * @var array
	 */
	private $selected_custom_post_types = [];

public static function get_name(): string {
		return 'wp-content';
	}

public function import( array $data, array $imported_data ) {
		$this->import_session_id = $data['session_id'];

$path = $data['extracted_directory_path'] . 'wp-content/';

$post_types = $this->filter_post_types( $data['selected_custom_post_types'] );

$taxonomies = $imported_data['taxonomies'] ?? [];
		$imported_terms = ImportExportUtils::map_old_new_term_ids( $imported_data );

$result['wp-content'] = [];

foreach ( $post_types as $post_type ) {
			$import = $this->import_wp_post_type(
				$path,
				$post_type,
				$imported_data,
				$taxonomies,
				$imported_terms
			);

if ( empty( $import ) ) {
				continue;
			}

$result['wp-content'][ $post_type ] = $import;
			$imported_data = array_merge( $imported_data, $result );
		}

return $result;
	}

private function import_wp_post_type( $path, $post_type, array $imported_data, array $taxonomies, array $imported_terms ) {
		$args = [
			'fetch_attachments' => true,
			'posts' => ImportExportUtils::map_old_new_post_ids( $imported_data ),
			'terms' => $imported_terms,
			'taxonomies' => ! empty( $taxonomies[ $post_type ] ) ? $taxonomies[ $post_type ] : [],
			'posts_meta' => [
				static::META_KEY_ELEMENTOR_IMPORT_SESSION_ID => $this->import_session_id,
			],
			'terms_meta' => [
				static::META_KEY_ELEMENTOR_IMPORT_SESSION_ID => $this->import_session_id,
			],
		];

$file = $path . $post_type . '/' . $post_type . '.xml';

if ( ! file_exists( $file ) ) {
			return [];
		}

$wp_importer = new WP_Import( $file, $args );
		$result = $wp_importer->run();

return $result['summary']['posts'];
	}

private function filter_post_types( $selected_custom_post_types = [] ) {
		$wp_builtin_post_types = ImportExportUtils::get_builtin_wp_post_types();

foreach ( $selected_custom_post_types as $custom_post_type ) {
			if ( post_type_exists( $custom_post_type ) ) {
				$this->selected_custom_post_types[] = $custom_post_type;
			}
		}

$post_types = array_merge( $wp_builtin_post_types, $this->selected_custom_post_types );
		$post_types = $this->force_element_to_be_last_by_value( $post_types, 'nav_menu_item' );

return $post_types;
	}

public function get_import_session_metadata(): array {
		return [
			'custom_post_types' => $this->selected_custom_post_types,
		];
	}

/**
	 * @param array $base_array The array we want to relocate his element.
	 * @param mixed $element    The value of the element in the array we want to shift to end of the array.
	 * @return mixed
	 */
	private function force_element_to_be_last_by_value( array $base_array, $element ) {
		$index = array_search( $element, $base_array, true );

if ( false !== $index ) {
			unset( $base_array[ $index ] );
			$base_array[] = $element;
		}

return $base_array;
	}
}
PK������,�\TQҟx��x��;��modules/import-export/runners/import/import-runner-base.phpnu��[�����������<?php

namespace Elementor\App\Modules\ImportExport\Runners\Import;

use Elementor\App\Modules\ImportExport\Runners\Runner_Interface;

abstract class Import_Runner_Base implements Runner_Interface {

/**
	 * By the passed data we should decide if we want to run the import function of the runner or not.
	 *
	 * @param array $data
	 *
	 * @return bool
	 */
	abstract public function should_import( array $data );

/**
	 * Main function of the runner import process.
	 *
	 * @param array $data Necessary data for the import process.
	 * @param array $imported_data Data that already imported by previously runners.
	 *
	 * @return array The result of the import process
	 */
	abstract public function import( array $data, array $imported_data );

public function get_import_session_metadata(): array {
		return [];
	}

public function set_session_post_meta( $post_id, $meta_value ) {
		update_post_meta( $post_id, static::META_KEY_ELEMENTOR_IMPORT_SESSION_ID, $meta_value );
	}

public function set_session_term_meta( $term_id, $meta_value ) {
		update_term_meta( $term_id, static::META_KEY_ELEMENTOR_IMPORT_SESSION_ID, $meta_value );
	}
}
PK������,�\�;>_������.��modules/import-export/compatibility/envato.phpnu��[�����������<?php

namespace Elementor\App\Modules\ImportExport\Compatibility;

use Elementor\App\Modules\ImportExport\Utils as ImportExportUtils;
use Elementor\Plugin;

if ( ! defined( 'ABSPATH' ) ) {
	exit; // Exit if accessed directly.
}

class Envato extends Base_Adapter {
	public static function is_compatibility_needed( array $manifest_data, array $meta ) {
		return ! empty( $manifest_data['manifest_version'] );
	}

public function adapt_manifest( array $manifest_data ) {
		$templates = $manifest_data['templates'];

$manifest_data['templates'] = [];

foreach ( $templates as $template ) {
			// Envato store their global kit styles as a 'global.json' template file.
			// We need to be able to know the path to this specific 'global.json' since it functions as the site-settings.json
			$is_global = ! empty( $template['metadata']['template_type'] ) && 'global-styles' === $template['metadata']['template_type'];
			if ( $is_global ) {
				// Adding the path of the 'global.json' template to the manifest which will be used in the future.
				$manifest_data['path-to-envto-site-settings'] = $template['source'];

// Getting the site-settings because Envato stores them in one of the posts.
				$kit = Plugin::$instance->kits_manager->get_active_kit();
				$kit_tabs = $kit->get_tabs();
				unset( $kit_tabs['settings-site-identity'] );
				$manifest_data['site-settings'] = array_keys( $kit_tabs );

continue;
			}

// Evanto uses "type" instead of "doc_type"
			$template['doc_type'] = $template['type'];

// Evanto uses for "name" instead of "title"
			$template['title'] = $template['name'];

// Envato specifying an exact path to the template rather than using its "ID" as an index.
			// This extracts the "file name" part out of our exact source list and we treat that as an ID.
			$file_name_without_extension = str_replace( '.json', '', basename( $template['source'] ) );

// Append the template to the global list:
			$manifest_data['templates'][ $file_name_without_extension ] = $template;
		}

$manifest_data['name'] = $manifest_data['title'];

return $manifest_data;
	}

public function adapt_site_settings( array $site_settings, array $manifest_data, $path ) {
		if ( empty( $manifest_data['path-to-envto-site-settings'] ) ) {
			return $site_settings;
		}

$global_file_path = $path . $manifest_data['path-to-envto-site-settings'];
		$global_file_data = ImportExportUtils::read_json_file( $global_file_path );

return [
			'settings' => $global_file_data['page_settings'],
		];
	}

public function adapt_template( array $template_data, array $template_settings ) {
		if ( ! empty( $template_data['metadata']['elementor_pro_conditions'] ) ) {
			foreach ( $template_data['metadata']['elementor_pro_conditions'] as $condition ) {
				list ( $type, $name, $sub_name, $sub_id ) = array_pad( explode( '/', $condition ), 4, '' );

$template_data['import_settings']['conditions'][] = compact( 'type', 'name', 'sub_name', 'sub_id' );
			}
		}

return $template_data;
	}
}
PK������,�\�g��������4��modules/import-export/compatibility/base-adapter.phpnu��[�����������<?php

namespace Elementor\App\Modules\ImportExport\Compatibility;

use Elementor\App\Modules\ImportExport\Import;
use Elementor\Core\Base\Base_Object;

if ( ! defined( 'ABSPATH' ) ) {
	exit; // Exit if accessed directly.
}

abstract class Base_Adapter {

/**
	 * @param array $manifest_data
	 * @param array $meta
	 * @return false
	 */
	public static function is_compatibility_needed( array $manifest_data, array $meta ) {
		return false;
	}

public function adapt_manifest( array $manifest_data ) {
		return $manifest_data;
	}

public function adapt_site_settings( array $site_settings, array $manifest_data, $path ) {
		return $site_settings;
	}

public function adapt_template( array $template_data, array $template_settings ) {
		return $template_data;
	}
}
PK������,�\���������3��modules/import-export/compatibility/kit-library.phpnu��[�����������<?php

namespace Elementor\App\Modules\ImportExport\Compatibility;

if ( ! defined( 'ABSPATH' ) ) {
	exit; // Exit if accessed directly.
}

class Kit_Library extends Base_Adapter {
	public static function is_compatibility_needed( array $manifest_data, array $meta ) {
		return ! empty( $meta['referrer'] ) && 'kit-library' === $meta['referrer'];
	}

public function adapt_manifest( array $manifest_data ) {
		if ( ! empty( $manifest_data['content']['page'] ) ) {
			foreach ( $manifest_data['content']['page'] as & $page ) {
				$page['thumbnail'] = false;
			}
		}

if ( ! empty( $manifest_data['templates'] ) ) {
			foreach ( $manifest_data['templates'] as & $template ) {
				$template['thumbnail'] = false;
			}
		}

return $manifest_data;
	}
}
PK������,�\uegf���f��� ��modules/import-export/module.phpnu��[�����������<?php
namespace Elementor\App\Modules\ImportExport;

use Elementor\App\Modules\ImportExport\Processes\Export;
use Elementor\App\Modules\ImportExport\Processes\Import;
use Elementor\App\Modules\ImportExport\Processes\Revert;
use Elementor\Core\Base\Module as BaseModule;
use Elementor\Core\Common\Modules\Ajax\Module as Ajax;
use Elementor\Core\Files\Uploads_Manager;
use Elementor\Modules\System_Info\Reporters\Server;
use Elementor\Plugin;
use Elementor\Tools;
use Elementor\Utils as ElementorUtils;
use Elementor\App\Modules\ImportExport\Utils as ImportExportUtils;
use Elementor\Modules\CloudKitLibrary\Module as CloudKitLibrary;

if ( ! defined( 'ABSPATH' ) ) {
	exit; // Exit if accessed directly.
}

/**
 * Import Export Module
 *
 * Responsible for initializing Elementor App functionality
 */
class Module extends BaseModule {
	const FORMAT_VERSION = '2.0';

const EXPORT_TRIGGER_KEY = 'elementor_export_kit';

const UPLOAD_TRIGGER_KEY = 'elementor_upload_kit';

const IMPORT_TRIGGER_KEY = 'elementor_import_kit';

const IMPORT_RUNNER_TRIGGER_KEY = 'elementor_import_kit__runner';

const REFERRER_KIT_LIBRARY = 'kit-library';

const REFERRER_LOCAL = 'local';

const REFERRER_CLOUD = 'cloud';

const PLUGIN_PERMISSIONS_ERROR_KEY = 'plugin-installation-permissions-error';

const KIT_LIBRARY_ERROR_KEY = 'invalid-kit-library-zip-error';

const NO_WRITE_PERMISSIONS_KEY = 'no-write-permissions';

const THIRD_PARTY_ERROR = 'third-party-error';

const DOMDOCUMENT_MISSING = 'domdocument-missing';

const OPTION_KEY_ELEMENTOR_IMPORT_SESSIONS = 'elementor_import_sessions';

const OPTION_KEY_ELEMENTOR_REVERT_SESSIONS = 'elementor_revert_sessions';

const META_KEY_ELEMENTOR_IMPORT_SESSION_ID = '_elementor_import_session_id';

const META_KEY_ELEMENTOR_EDIT_MODE = '_elementor_edit_mode';
	const IMPORT_PLUGINS_ACTION = 'import-plugins';
	const EXPORT_SOURCE_CLOUD = 'cloud';
	const EXPORT_SOURCE_FILE = 'file';

/**
	 * Assigning the export process to a property, so we can use the process from outside the class.
	 *
	 * @var Export
	 */
	public $export;

/**
	 * Assigning the import process to a property, so we can use the process from outside the class.
	 *
	 * @var Import
	 */
	public $import;

/**
	 * Assigning the revert process to a property, so we can use the process from outside the class.
	 *
	 * @var Revert
	 */
	public $revert;

/**
	 * Get name.
	 *
	 * @access public
	 *
	 * @return string
	 */
	public function get_name() {
		return 'import-export';
	}

public function __construct() {
		$this->register_actions();

if ( ElementorUtils::is_wp_cli() ) {
			\WP_CLI::add_command( 'elementor kit', WP_CLI::class );
		}

( new Usage() )->register();

$this->revert = new Revert();
	}

public function get_init_settings() {
		if ( ! Plugin::$instance->app->is_current() ) {
			return [];
		}

return $this->get_config_data();
	}

/**
	 * Register the import/export tab in elementor tools.
	 */
	public function register_settings_tab( Tools $tools ) {
		$tools->add_tab( 'import-export-kit', [
			'label' => esc_html__( 'Website Templates', 'elementor' ),
			'sections' => [
				'intro' => [
					'label' => esc_html__( 'Website Templates', 'elementor' ),
					'callback' => function() {
						$this->render_import_export_tab_content();
					},
					'fields' => [],
				],
			],
		] );
	}

/**
	 * Render the import/export tab content.
	 */
	private function render_import_export_tab_content() {
		$is_cloud_kits_available = CloudKitLibrary::get_app()->check_eligibility()['is_eligible'];

$content_data = [
			'export' => [
				'title' => esc_html__( 'Export this website', 'elementor' ),
				'button' => [
					'url' => Plugin::$instance->app->get_base_url() . '#/export',
					'text' => esc_html__( 'Export', 'elementor' ),
					'id' => 'elementor-import-export__export',
				],
				'description' => esc_html__( 'You can download this website as a .zip file, or upload it to the library.', 'elementor' ),
			],
			'import' => [
				'title' => esc_html__( 'Import website templates', 'elementor' ),
				'button' => [
					'url' => Plugin::$instance->app->get_base_url() . '#/import',
					'text' => esc_html__( 'Import', 'elementor' ),
					'id' => 'elementor-import-export__import',
				],
				'description' => esc_html__( 'You can import design and settings from a .zip file or choose from the library.', 'elementor' ),
			],
		];

if ( $is_cloud_kits_available ) {
			$content_data['import']['button_secondary'] = [
				'url' => Plugin::$instance->app->get_base_url() . '#/kit-library/cloud',
				'text' => esc_html__( 'Import from library', 'elementor' ),
				'id' => 'elementor-import-export__import_from_library',
			];
		}

$last_imported_kit = $this->revert->get_last_import_session();
		$penultimate_imported_kit = $this->revert->get_penultimate_import_session();

$user_date_format = get_option( 'date_format' );
		$user_time_format = get_option( 'time_format' );
		$date_format = $user_date_format . ' ' . $user_time_format;

$should_show_revert_section = $this->should_show_revert_section( $last_imported_kit );

if ( $should_show_revert_section ) {
			if ( ! empty( $penultimate_imported_kit ) ) {
				$revert_text = sprintf(
					/* translators: 1: Last imported kit title, 2: Last imported kit date, 3: Line break <br>, 4: Penultimate imported kit title, 5: Penultimate imported kit date. */
					esc_html__( 'Remove all the content and site settings that came with "%1$s" on %2$s %3$s and revert to the site setting that came with "%4$s" on %5$s.', 'elementor' ),
					! empty( $last_imported_kit['kit_title'] ) ? $last_imported_kit['kit_title'] : esc_html__( 'imported kit', 'elementor' ),
					gmdate( $date_format, $last_imported_kit['start_timestamp'] ),
					'<br>',
					! empty( $penultimate_imported_kit['kit_title'] ) ? $penultimate_imported_kit['kit_title'] : esc_html__( 'imported kit', 'elementor' ),
					gmdate( $date_format, $penultimate_imported_kit['start_timestamp'] )
				);
			} else {
				$revert_text = sprintf(
					/* translators: 1: Last imported kit title, 2: Last imported kit date, 3: Line break <br>. */
					esc_html__( 'Remove all the content and site settings that came with "%1$s" on %2$s.%3$s Your original site settings will be restored.', 'elementor' ),
					! empty( $last_imported_kit['kit_title'] ) ? $last_imported_kit['kit_title'] : esc_html__( 'imported kit', 'elementor' ),
					gmdate( $date_format, $last_imported_kit['start_timestamp'] ),
					'<br>'
				);
			}
		}
		?>

<div class="tab-import-export-kit__content">
			<p class="tab-import-export-kit__info">
				<?php
				printf(
					'%1$s <a href="https://go.elementor.com/wp-dash-import-export-general/" target="_blank">%2$s</a>',
					esc_html__( 'Here’s where you can export this website as a .zip file, upload it to the cloud, or start the process of applying an existing template to your site.', 'elementor' ),
					esc_html__( 'Learn more', 'elementor' ),
				);
				?>
			</p>

<div class="tab-import-export-kit__wrapper">
				<?php foreach ( $content_data as $data ) {
					$this->print_item_content( $data );
				} ?>
			</div>

<?php
			if ( $should_show_revert_section ) {

$link_attributes = [
					'href' => $this->get_revert_href(),
					'id' => 'elementor-import-export__revert_kit',
					'class' => 'button',
				];
				?>
				<div class="tab-import-export-kit__revert">
					<h2>
						<?php echo esc_html__( 'Remove the most recent Website Template', 'elementor' ); ?>
					</h2>
					<p class="tab-import-export-kit__info">
						<?php ElementorUtils::print_unescaped_internal_string( $revert_text ); ?>
					</p>
					<?php $this->render_last_kit_thumbnail( $last_imported_kit ); ?>
					<a <?php ElementorUtils::print_html_attributes( $link_attributes ); ?> >
						<?php echo esc_html__( 'Remove Website Template', 'elementor' ); ?>
					</a>
				</div>
			<?php } ?>
		</div>
		<?php
	}

private function print_item_content( $data ) {
		?>
		<div class="tab-import-export-kit__container">
			<div class="tab-import-export-kit__box">
				<h2><?php ElementorUtils::print_unescaped_internal_string( $data['title'] ); ?></h2>
			</div>
			<p class="description"><?php ElementorUtils::print_unescaped_internal_string( $data['description'] ); ?></p>

<?php if ( ! empty( $data['link'] ) ) : ?>
				<a href="<?php ElementorUtils::print_unescaped_internal_string( $data['link']['url'] ); ?>" target="_blank"><?php ElementorUtils::print_unescaped_internal_string( $data['link']['text'] ); ?></a>
			<?php endif; ?>
			<div class="tab-import-export-kit__box action-buttons">
				<?php if ( ! empty( $data['button_secondary'] ) ) : ?>
					<a href="<?php ElementorUtils::print_unescaped_internal_string( $data['button_secondary']['url'] ); ?>" class="elementor-button e-btn-txt e-btn-txt-border">
						<?php ElementorUtils::print_unescaped_internal_string( $data['button_secondary']['text'] ); ?>
					</a>
				<?php endif; ?>
				<a <?php ElementorUtils::print_html_attributes( [ 'id' => $data['button']['id'] ] ); ?> href="<?php ElementorUtils::print_unescaped_internal_string( $data['button']['url'] ); ?>" class="elementor-button e-primary">
					<?php ElementorUtils::print_unescaped_internal_string( $data['button']['text'] ); ?>
				</a>
			</div>
		</div>
		<?php
	}

private function get_revert_href(): string {
		$admin_post_url = admin_url( 'admin-post.php?action=elementor_revert_kit' );
		$nonced_admin_post_url = wp_nonce_url( $admin_post_url, 'elementor_revert_kit' );
		return $this->maybe_add_referrer_param( $nonced_admin_post_url );
	}

/**
	 * Checks if referred by a kit and adds the referrer ID to the href
	 *
	 * @param string $href
	 *
	 * @return string
	 */
	private function maybe_add_referrer_param( string $href ): string {
		$param_name = 'referrer_kit';

if ( empty( $_GET[ $param_name ] ) ) {
			return $href;
		}

return add_query_arg( $param_name, sanitize_key( $_GET[ $param_name ] ), $href );
	}

/**
	 * Render the last kit thumbnail if exists
	 *
	 * @param $last_imported_kit
	 *
	 * @return void
	 */
	private function render_last_kit_thumbnail( $last_imported_kit ) {
		if ( empty( $last_imported_kit['kit_thumbnail'] ) ) {
			return;
		}

?>
		<div class="tab-import-export-kit__kit-item-row">
			<article class="tab-import-export-kit__kit-item">
				<header>
					<h3>
						<?php echo esc_html( $last_imported_kit['kit_title'] ); ?>
					</h3>
				</header>
				<img
					src="<?php echo esc_url( $last_imported_kit['kit_thumbnail'] ); ?>"
					alt="<?php echo esc_attr( $last_imported_kit['kit_title'] ); ?>"
					loading="lazy"
				>
			</article>
		</div>
		<?php
	}

/**
	 * Upload a kit zip file and get the kit data.
	 *
	 * Assigning the Import process to the 'import' property,
	 * so it will be available to use in different places such as: WP_Cli, Pro, etc.
	 *
	 * @param string $file Path to the file.
	 * @param string $referrer Referrer of the file 'local' or 'kit-library'.
	 * @param string $kit_id
	 * @return array
	 * @throws \Exception If export validation fails or processing errors occur.
	 */
	public function upload_kit( $file, $referrer, $kit_id = null ) {
		$this->ensure_writing_permissions();

$this->import = new Import( $file, [
			'referrer' => $referrer,
			'id' => $kit_id,
		] );

return [
			'session' => $this->import->get_session_id(),
			'manifest' => $this->import->get_manifest(),
			'conflicts' => $this->import->get_settings_conflicts(),
		];
	}

/**
	 * Import a kit by session_id.
	 * Upload and import a kit by kit zip file.
	 *
	 * If the split_to_chunks flag is true, the process won't start
	 * It will initialize the import process and return the session_id and the runners.
	 *
	 * Assigning the Import process to the 'import' property,
	 * so it will be available to use in different places such as: WP_Cli, Pro, etc.
	 *
	 * @param string $path Path to the file or session_id.
	 * @param array  $settings Settings the import use to determine which content to import.
	 *       (e.g: include, selected_plugins, selected_cpt, selected_override_conditions, etc.)
	 * @param bool   $split_to_chunks Determine if the import process should be split into chunks.
	 * @return array
	 * @throws \Exception If export configuration is invalid or processing fails.
	 */
	public function import_kit( string $path, array $settings, bool $split_to_chunks = false ): array {
		$this->ensure_writing_permissions();
		$this->ensure_DOMDocument_exists();

$this->import = new Import( $path, $settings );
		$this->import->register_default_runners();

remove_filter( 'elementor/document/save/data', [ Plugin::$instance->modules_manager->get_modules( 'content-sanitizer' ), 'sanitize_content' ] );
		do_action( 'elementor/import-export/import-kit', $this->import );

if ( $split_to_chunks ) {
			$this->import->init_import_session( true );

return [
				'session' => $this->import->get_session_id(),
				'runners' => $this->import->get_runners_name(),
			];
		}

return $this->import->run();
	}

/**
	 * Resuming import process by re-creating the import instance and running the specific runner.
	 *
	 * @param string $session_id The id off the import session.
	 * @param string $runner_name The specific runner that we want to run.
	 *
	 * @return array Two types of response.
	 *      1. The status and the runner name.
	 *      2. The imported data. (Only if the runner is the last one in the import process)
	 * @throws \Exception If import configuration is invalid or processing fails.
	 */
	public function import_kit_by_runner( string $session_id, string $runner_name ): array {
		// Check session_id
		$this->import = Import::from_session( $session_id );
		$runners = $this->import->get_runners_name();

$run = $this->import->run_runner( $runner_name );

if ( end( $runners ) === $run['runner'] ) {
			return $this->import->get_imported_data();
		}

return $run;
	}

/**
	 * Export a kit.
	 *
	 * Assigning the Export process to the 'export' property,
	 * so it will be available to use in different places such as: WP_Cli, Pro, etc.
	 *
	 * @param array $settings Settings the export use to determine which content to export.
	 *      (e.g: include, kit_info, selected_plugins, selected_cpt, etc.)
	 * @return array
	 * @throws \Exception If import/export process fails or validation errors occur.
	 */
	public function export_kit( array $settings ) {
		$this->ensure_writing_permissions();

$this->export = new Export( $settings );
		$this->export->register_default_runners();

do_action( 'elementor/import-export/export-kit', $this->export );

return $this->export->run();
	}

/**
	 * Handle revert kit ajax request.
	 */
	public function revert_last_imported_kit() {
		$this->revert = new Revert();
		$this->revert->register_default_runners();

do_action( 'elementor/import-export/revert-kit', $this->revert );

$this->revert->run();
	}

/**
	 * Handle revert last imported kit ajax request.
	 */
	public function handle_revert_last_imported_kit() {
		check_admin_referer( 'elementor_revert_kit' );

$this->revert_last_imported_kit();

wp_safe_redirect( admin_url( 'admin.php?page=' . Tools::PAGE_ID . '#tab-import-export-kit' ) );
		die;
	}

/**
	 * Register appropriate actions.
	 */
	private function register_actions() {
		add_action( 'admin_init', function() {
			if ( wp_doing_ajax() &&
				isset( $_POST['action'] ) &&
				wp_verify_nonce( ElementorUtils::get_super_global_value( $_POST, '_nonce' ), Ajax::NONCE_KEY ) &&
				current_user_can( 'manage_options' )
			) {
				$this->maybe_handle_ajax();
			}
		} );

add_action( 'admin_post_elementor_revert_kit', [ $this, 'handle_revert_last_imported_kit' ] );

add_action( 'admin_enqueue_scripts', [ $this, 'enqueue_scripts' ] );

if ( ! Plugin::$instance->experiments->is_feature_active( 'import-export-customization' ) ) {
			$page_id = Tools::PAGE_ID;

add_action( "elementor/admin/after_create_settings/{$page_id}", [ $this, 'register_settings_tab' ] );
		}

// TODO 18/04/2023 : This needs to be moved to the runner itself after https://elementor.atlassian.net/browse/HTS-434 is done.
		if ( self::IMPORT_PLUGINS_ACTION === ElementorUtils::get_super_global_value( $_SERVER, 'HTTP_X_ELEMENTOR_ACTION' ) ) {
			add_filter( 'woocommerce_create_pages', [ $this, 'empty_pages' ], 10, 0 );
		}
		// TODO ^^^

add_filter( 'elementor/import/kit/result', function( $result ) {
			if ( ! empty( $result['file_url'] ) ) {
				return [
					'file_name' => $this->get_remote_kit_zip( $result['file_url'] ),
					'referrer' => static::REFERRER_KIT_LIBRARY,
					'file_url' => $result['file_url'],
				];
			}

return $result;
		} );
	}

/**
	 * Prevent the creation of the default WooCommerce pages (Cart, Checkout, etc.)
	 *
	 * TODO 18/04/2023 : This needs to be moved to the runner itself after https://elementor.atlassian.net/browse/HTS-434 is done.
	 *
	 * @return array
	 */
	public function empty_pages(): array {
		return [];
	}

private function ensure_writing_permissions() {
		$server = new Server();

$paths_to_check = [
			Server::KEY_PATH_WP_CONTENT_DIR => $server->get_system_path( Server::KEY_PATH_WP_CONTENT_DIR ),
			Server::KEY_PATH_UPLOADS_DIR => $server->get_system_path( Server::KEY_PATH_UPLOADS_DIR ),
			Server::KEY_PATH_ELEMENTOR_UPLOADS_DIR => $server->get_system_path( Server::KEY_PATH_ELEMENTOR_UPLOADS_DIR ),
		];

$permissions = $server->get_paths_permissions( $paths_to_check );

// WP Content dir has to be exists and writable.
		if ( ! $permissions[ Server::KEY_PATH_WP_CONTENT_DIR ]['write'] ) {
			throw new \Error( self::NO_WRITE_PERMISSIONS_KEY ); // phpcs:ignore WordPress.Security.EscapeOutput.ExceptionNotEscaped
		}

// WP Uploads dir has to be exists and writable.
		if ( ! $permissions[ Server::KEY_PATH_UPLOADS_DIR ]['write'] ) {
			throw new \Error( self::NO_WRITE_PERMISSIONS_KEY ); // phpcs:ignore WordPress.Security.EscapeOutput.ExceptionNotEscaped
		}

// Elementor uploads dir permissions is divided to 2 cases:
		// 1. If the dir exists, it has to be writable.
		// 2. If the dir doesn't exist, the parent dir has to be writable (wp uploads dir), so we can create it.
		if ( $permissions[ Server::KEY_PATH_ELEMENTOR_UPLOADS_DIR ]['exists'] && ! $permissions[ Server::KEY_PATH_ELEMENTOR_UPLOADS_DIR ]['write'] ) {
			throw new \Error( self::NO_WRITE_PERMISSIONS_KEY ); // phpcs:ignore WordPress.Security.EscapeOutput.ExceptionNotEscaped
		}
	}

private function ensure_DOMDocument_exists() {
		if ( ! class_exists( 'DOMDocument' ) ) {
			throw new \Error( self::DOMDOCUMENT_MISSING ); // phpcs:ignore WordPress.Security.EscapeOutput.ExceptionNotEscaped
		}
	}

/**
	 * Enqueue admin scripts
	 */
	public function enqueue_scripts() {
		wp_enqueue_script(
			'elementor-import-export-admin',
			$this->get_js_assets_url( 'import-export-admin' ),
			[ 'elementor-common' ],
			ELEMENTOR_VERSION,
			true
		);

wp_localize_script(
			'elementor-import-export-admin',
			'elementorImportExport',
			[
				'lastImportedSession' => $this->revert->get_last_import_session(),
				'appUrl' => Plugin::$instance->app->get_base_url() . '#/kit-library',
			]
		);
	}

/**
	 * Assign each ajax action to a method.
	 */
	private function maybe_handle_ajax() {
		// phpcs:ignore WordPress.Security.NonceVerification.Missing
		$action = ElementorUtils::get_super_global_value( $_POST, 'action' );

try {
			switch ( $action ) {
				case static::EXPORT_TRIGGER_KEY:
					$this->handle_export_kit();
					break;

case static::UPLOAD_TRIGGER_KEY:
					$this->handle_upload_kit();
					break;

case static::IMPORT_TRIGGER_KEY:
					$this->handle_import_kit();
					break;

case static::IMPORT_RUNNER_TRIGGER_KEY:
					$this->handle_import_kit__runner();
					break;

default:
					break;
			}
		} catch ( \Error $e ) {
			if ( isset( $this->import ) ) {
				$this->import->finalize_import_session_option();
			}

Plugin::$instance->logger->get_logger()->error( $e->getMessage(), [
				'meta' => [
					'trace' => $e->getTraceAsString(),
				],
			] );

if ( isset( $this->import ) && $this->is_third_party_class( $e->getTrace()[0]['class'] ) ) {
				wp_send_json_error( self::THIRD_PARTY_ERROR, 500 );
			}

wp_send_json_error( $e->getMessage(), 500 );
		}
	}

/**
	 * Handle upload kit ajax request.
	 *
	 * @throws \Error If operation validation fails or processing errors occur.
	 */
	private function handle_upload_kit() {
		// PHPCS - A URL that should contain special chars (auth headers information).
		$file_url = isset( $_POST['e_import_file'] )
			// phpcs:ignore WordPress.Security.ValidatedSanitizedInput.InputNotSanitized
			? wp_unslash( $_POST['e_import_file'] )
			: '';

// PHPCS - Already validated in caller function
		$kit_id = ElementorUtils::get_super_global_value( $_POST, 'kit_id' ); // phpcs:ignore WordPress.Security.NonceVerification.Missing
		$source = ElementorUtils::get_super_global_value( $_POST, 'source' ); // phpcs:ignore WordPress.Security.NonceVerification.Missing

$is_import_from_library = ! empty( $file_url );

if ( $is_import_from_library ) {
			if (
				! wp_verify_nonce( ElementorUtils::get_super_global_value( $_POST, 'e_kit_library_nonce' ), 'kit-library-import' )
			) {
				throw new \Error( 'Invalid kit library nonce.' );
			}

if ( ! filter_var( $file_url, FILTER_VALIDATE_URL ) || 0 !== strpos( $file_url, 'http' ) ) {
				throw new \Error( static::KIT_LIBRARY_ERROR_KEY ); // phpcs:ignore WordPress.Security.EscapeOutput.ExceptionNotEscaped
			}

$import_result = apply_filters( 'elementor/import/kit/result', [ 'file_url' => $file_url ] );
		} elseif ( ! empty( $source ) ) {
			$import_result = apply_filters( 'elementor/import/kit/result/' . $source, [
				'kit_id' => $kit_id,
				'source' => $source,
			] );
		} else {
			$import_result = [
				'file_name' => ElementorUtils::get_super_global_value( $_FILES, 'e_import_file' )['tmp_name'],
				'referrer' => static::REFERRER_LOCAL,
			];
		}

Plugin::$instance->logger->get_logger()->info( 'Uploading Kit: ', [
			'meta' => [
				'kit_id' => $kit_id,
				'referrer' => $import_result['referrer'],
			],
		] );

if ( is_wp_error( $import_result ) ) {
			wp_send_json_error( $import_result->get_error_message() );
		}

$uploaded_kit = $this->upload_kit( $import_result['file_name'], $import_result['referrer'], $kit_id );

$session_dir = $uploaded_kit['session'];
		$manifest = $uploaded_kit['manifest'];
		$conflicts = $uploaded_kit['conflicts'];

if ( $is_import_from_library || ! empty( $source ) ) {
			Plugin::$instance->uploads_manager->remove_file_or_dir( dirname( $import_result['file_name'] ) );
		}

if ( isset( $manifest['plugins'] ) && ! current_user_can( 'install_plugins' ) ) {
			throw new \Error( static::PLUGIN_PERMISSIONS_ERROR_KEY ); // phpcs:ignore WordPress.Security.EscapeOutput.ExceptionNotEscaped
		}

$result = [
			'session' => $session_dir,
			'manifest' => $manifest,
			'file_url' => $import_result['file_url'],
		];

if ( ! empty( $import_result['kit'] ) ) {
			$result['uploaded_kit'] = $import_result['kit'];
		}

if ( ! empty( $conflicts ) ) {
			$result['conflicts'] = $conflicts;
		} else {
			// Moved into the IE process \Elementor\App\Modules\ImportExport\Processes\Import::get_default_settings_conflicts
			// TODO: remove in 3.10.0
			$result = apply_filters( 'elementor/import/stage_1/result', $result );
		}

wp_send_json_success( $result );
	}

protected function get_remote_kit_zip( $url ) {
		$remote_zip_request = wp_safe_remote_get( $url );

if ( is_wp_error( $remote_zip_request ) ) {
			Plugin::$instance->logger->get_logger()->error( $remote_zip_request->get_error_message() );
			throw new \Error( static::KIT_LIBRARY_ERROR_KEY ); // phpcs:ignore WordPress.Security.EscapeOutput.ExceptionNotEscaped
		}

if ( 200 !== $remote_zip_request['response']['code'] ) {
			Plugin::$instance->logger->get_logger()->error( $remote_zip_request['response']['message'] );
			throw new \Error( static::KIT_LIBRARY_ERROR_KEY ); // phpcs:ignore WordPress.Security.EscapeOutput.ExceptionNotEscaped
		}

return Plugin::$instance->uploads_manager->create_temp_file( $remote_zip_request['body'], 'kit.zip' );
	}

/**
	 * Handle import kit ajax request.
	 */
	private function handle_import_kit() {
		// PHPCS - Already validated in caller function
		$settings = json_decode( ElementorUtils::get_super_global_value( $_POST, 'data' ), true ); // phpcs:ignore WordPress.Security.NonceVerification.Missing
		$tmp_folder_id = $settings['session'];

$import = $this->import_kit( $tmp_folder_id, $settings, true );

// get_settings_config() added manually because the frontend Ajax request doesn't trigger the get_init_settings().
		$import['configData'] = $this->get_config_data();

Plugin::$instance->logger->get_logger()->info(
			sprintf( 'Selected import runners: %1$s',
				implode( ', ', $import['runners'] )
			)
		);

wp_send_json_success( $import );
	}

/**
	 * Handle ajax request for running specific runner in the import kit process.
	 */
	private function handle_import_kit__runner() {
		// PHPCS - Already validated in caller function
		$settings = json_decode( ElementorUtils::get_super_global_value( $_POST, 'data' ), true ); // phpcs:ignore WordPress.Security.NonceVerification.Missing
		$session_id = $settings['session'];
		$runner = $settings['runner'];

$import = $this->import_kit_by_runner( $session_id, $runner );

// get_settings_config() added manually because the frontend Ajax request doesn't trigger the get_init_settings().
		$import['configData'] = $this->get_config_data();

if ( ! empty( $import['status'] ) ) {
			Plugin::$instance->logger->get_logger()->info(
				sprintf( 'Import runner completed: %1$s %2$s',
					$import['runner'],
					( 'success' === $import['status'] ? '✓' : '✗' )
				)
			);
		}

do_action( 'elementor/import-export/import-kit/runner/after-run', $import );

wp_send_json_success( $import );
	}

/**
	 * Handle export kit ajax request.
	 *
	 * @throws \Error If cleanup process fails or file system errors occur.
	 */
	private function handle_export_kit() {
		// PHPCS - Already validated in caller function
		$settings = json_decode( ElementorUtils::get_super_global_value( $_POST, 'data' ), true ); // phpcs:ignore WordPress.Security.NonceVerification.Missing
		$source = $settings['kitInfo']['source'];

$export = $this->export_kit( $settings );

$file_name = $export['file_name'];
		$file_size = filesize( $file_name );
		$file = ElementorUtils::file_get_contents( $file_name );

if ( ! $file ) {
			throw new \Error( 'Could not read the exported file.' );
		}

Plugin::$instance->uploads_manager->remove_file_or_dir( dirname( $file_name ) );

$result = apply_filters(
			'elementor/export/kit/export-result',
			[
				'manifest' => $export['manifest'],
				'file' => base64_encode( $file ),
			],
			$source,
			$export,
			$settings,
			$file,
			$file_size,
		);

if ( is_wp_error( $result ) ) {
			wp_send_json_error( $result );
		}

wp_send_json_success( $result );
	}

/**
	 * Get config data that will be exposed to the frontend.
	 */
	private function get_config_data() {
		$export_nonce = wp_create_nonce( 'elementor_export' );
		$export_url = add_query_arg( [ '_nonce' => $export_nonce ], Plugin::$instance->app->get_base_url() );

/**
	 * Get labels of Elementor document types, Elementor Post types, WordPress Post types and Custom Post types.
	 */
	private function get_summary_titles() {
		$summary_titles = [];

$document_types = Plugin::$instance->documents->get_document_types();

foreach ( $document_types as $name => $document_type ) {
			$summary_titles['templates'][ $name ] = [
				'single' => $document_type::get_title(),
				'plural' => $document_type::get_plural_title(),
			];
		}

$elementor_post_types = ImportExportUtils::get_elementor_post_types();
		$wp_builtin_post_types = ImportExportUtils::get_builtin_wp_post_types();
		$post_types = array_merge( $elementor_post_types, $wp_builtin_post_types );

foreach ( $post_types as $post_type ) {
			$post_type_object = get_post_type_object( $post_type );

$summary_titles['content'][ $post_type ] = [
				'single' => $post_type_object->labels->singular_name ?? '',
				'plural' => $post_type_object->label ?? '',
			];
		}

$custom_post_types = ImportExportUtils::get_registered_cpt_names();
		if ( ! empty( $custom_post_types ) ) {
			foreach ( $custom_post_types as $custom_post_type ) {

$custom_post_types_object = get_post_type_object( $custom_post_type );
				// CPT data appears in two arrays:
				// 1. content object: in order to show the export summary when completed in getLabel function
				$summary_titles['content'][ $custom_post_type ] = [
					'single' => $custom_post_types_object->labels->singular_name ?? '',
					'plural' => $custom_post_types_object->label ?? '',
				];

// 2. customPostTypes object: in order to actually export the data
				$summary_titles['content']['customPostTypes'][ $custom_post_type ] = [
					'single' => $custom_post_types_object->labels->singular_name ?? '',
					'plural' => $custom_post_types_object->label ?? '',
				];
			}
		}

$active_kit = Plugin::$instance->kits_manager->get_active_kit();

foreach ( $active_kit->get_tabs() as $key => $tab ) {
			$summary_titles['site-settings'][ $key ] = $tab->get_title();
		}

return $summary_titles;
	}

public function should_show_revert_section( $last_imported_kit ) {
		if ( empty( $last_imported_kit ) ) {
			return false;
		}

// TODO: BC - remove in the future
		// The 'templates' runner was in core and moved to the Pro plugin. (Part of it still exits in the Core for BC)
		// The runner that is in the core version is missing the revert functionality,
		// therefore we shouldn't display the revert section if the import process done with the core version.
		$is_import_templates_ran = isset( $last_imported_kit['runners']['templates'] );
		if ( $this->has_pro() && $is_import_templates_ran ) {
			$has_imported_templates = ! empty( $last_imported_kit['runners']['templates'] );

return $has_imported_templates;
		}

return true;
	}

public function has_pro(): bool {
		return ElementorUtils::has_pro();
	}

private function get_elementor_editor_home_page_url() {
		if ( 'page' !== get_option( 'show_on_front' ) ) {
			return '';
		}

$frontpage_id = get_option( 'page_on_front' );

return $this->get_elementor_editor_page_url( $frontpage_id );
	}

private function get_elementor_home_page_url() {
		if ( 'page' !== get_option( 'show_on_front' ) ) {
			return '';
		}

$frontpage_id = get_option( 'page_on_front' );

return $this->get_elementor_page_url( $frontpage_id );
	}

private function get_recently_edited_elementor_page_url() {
		$query = ElementorUtils::get_recently_edited_posts_query( [ 'posts_per_page' => 1 ] );

if ( ! isset( $query->post ) ) {
			return '';
		}

return $this->get_elementor_page_url( $query->post->ID );
	}

private function get_recently_edited_elementor_editor_page_url() {
		$query = ElementorUtils::get_recently_edited_posts_query( [ 'posts_per_page' => 1 ] );

if ( ! isset( $query->post ) ) {
			return '';
		}

return $this->get_elementor_editor_page_url( $query->post->ID );
	}

private function get_elementor_document( $page_id ) {
		$document = Plugin::$instance->documents->get( $page_id );

if ( ! $document || ! $document->is_built_with_elementor() ) {
			return false;
		}

return $document;
	}

private function get_elementor_page_url( $page_id ) {
		$document = $this->get_elementor_document( $page_id );

return $document ? $document->get_preview_url() : '';
	}

private function get_elementor_editor_page_url( $page_id ) {
		$document = $this->get_elementor_document( $page_id );

return $document ? $document->get_edit_url() : '';
	}

/**
	 * @param string $class_name
	 *
	 * @return bool
	 */
	public function is_third_party_class( $class_name ) {
		$allowed_classes = [
			'Elementor\\',
			'ElementorPro\\',
			'WP_',
			'wp_',
		];

foreach ( $allowed_classes as $allowed_class ) {
			if ( str_starts_with( $class_name, $allowed_class ) ) {
				return false;
			}
		}

return true;
	}
}
PK������,�\A�pR
��
����modules/import-export/usage.phpnu��[�����������<?php

namespace Elementor\App\Modules\ImportExport;

use Elementor\App\Modules\ImportExport\Processes\Revert;

if ( ! defined( 'ABSPATH' ) ) {
	exit; // Exit if accessed directly.
}

class Usage {

/**
	 * Register hooks.
	 *
	 * @return void
	 */
	public function register() {
		add_filter( 'elementor/tracker/send_tracking_data_params', function ( array $params ) {
			$params['usages']['import_export']['revert'] = $this->get_revert_usage_data();

return $params;
		} );
	}

/**
	 * Get the Revert usage data.
	 *
	 * @return array
	 */
	private function get_revert_usage_data() {
		$revert_sessions = ( new Revert() )->get_revert_sessions();

$data = [];

foreach ( $revert_sessions as $revert_session ) {
			$data[] = [
				'kit_name' => $revert_session['kit_name'],
				'source' => $revert_session['source'],
				'revert_timestamp' => (int) $revert_session['revert_timestamp'],
				'total_time' => ( (int) $revert_session['revert_timestamp'] - (int) $revert_session['import_timestamp'] ),
			];
		}

return $data;
	}
}
PK������,�\u����������modules/import-export/utils.phpnu��[�����������<?php

namespace Elementor\App\Modules\ImportExport;

use Elementor\Core\Utils\Str;
use Elementor\Modules\LandingPages\Module as Landing_Pages_Module;
use Elementor\Modules\FloatingButtons\Module as Floating_Buttons_Module;
use Elementor\TemplateLibrary\Source_Local;
use Elementor\Utils as ElementorUtils;

class Utils {

public static function read_json_file( $path ) {
		if ( ! Str::ends_with( $path, '.json' ) ) {
			$path .= '.json';
		}

$file_content = ElementorUtils::file_get_contents( $path, true );

return $file_content ? json_decode( $file_content, true ) : [];
	}

public static function map_old_new_post_ids( array $imported_data ) {
		$result = [];

$result += $imported_data['templates']['succeed'] ?? [];

if ( isset( $imported_data['content'] ) ) {
			foreach ( $imported_data['content'] as $post_type ) {
				$result += $post_type['succeed'] ?? [];
			}
		}

if ( isset( $imported_data['wp-content'] ) ) {
			foreach ( $imported_data['wp-content'] as $post_type ) {
				$result += $post_type['succeed'] ?? [];
			}
		}

return $result;
	}

public static function map_old_new_term_ids( array $imported_data ) {
		$result = [];

if ( ! isset( $imported_data['taxonomies'] ) ) {
			return $result;
		}

foreach ( $imported_data['taxonomies'] as $post_type_taxonomies ) {
			foreach ( $post_type_taxonomies as $taxonomy ) {
				foreach ( $taxonomy as $term ) {
					$result[ $term['old_id'] ] = $term['new_id'];
				}
			}
		}

return $result;
	}

public static function get_elementor_post_types() {
		$elementor_post_types = get_post_types_by_support( 'elementor' );

return array_filter( $elementor_post_types, function ( $value ) {
			// Templates are handled in a separate process.
			return 'elementor_library' !== $value;
		} );
	}

public static function get_builtin_wp_post_types() {
		return [ 'post', 'page', 'nav_menu_item' ];
	}

public static function get_registered_cpt_names() {
		$post_types = get_post_types( [
			'public' => true,
			'can_export' => true,
			'_builtin' => false,
		] );

unset(
			$post_types[ Landing_Pages_Module::CPT ],
			$post_types[ Source_Local::CPT ],
			$post_types[ Floating_Buttons_Module::CPT_FLOATING_BUTTONS ]
		);

return array_keys( $post_types );
	}

/**
	 * Transform a string name to title format.
	 *
	 * @param $name
	 *
	 * @return string
	 */
	public static function transform_name_to_title( $name ): string {
		if ( empty( $name ) ) {
			return '';
		}

$title = str_replace( [ '-', '_' ], ' ', $name );

return ucwords( $title );
	}

public static function get_import_sessions( $should_run_cleanup = false ) {
		$import_sessions = get_option( Module::OPTION_KEY_ELEMENTOR_IMPORT_SESSIONS, [] );

if ( $should_run_cleanup ) {
			foreach ( $import_sessions as $session_id => $import_session ) {
				if ( ! isset( $import_session['runners'] ) && isset( $import_session['instance_data'] ) ) {
					$import_sessions[ $session_id ]['runners'] = $import_session['instance_data']['runners_import_metadata'] ?? [];

unset( $import_sessions[ $session_id ]['instance_data'] );
				}
			}

update_option( Module::OPTION_KEY_ELEMENTOR_IMPORT_SESSIONS, $import_sessions );
		}

return $import_sessions;
	}

public static function update_space_between_widgets_values( $space_between_widgets ) {
		$setting_exist = isset( $space_between_widgets['size'] );
		$already_processed = isset( $space_between_widgets['column'] );

if ( ! $setting_exist || $already_processed ) {
			return $space_between_widgets;
		}

$size = strval( $space_between_widgets['size'] );
		$space_between_widgets['column'] = $size;
		$space_between_widgets['row'] = $size;
		$space_between_widgets['isLinked'] = true;

return $space_between_widgets;
	}
}
PK������,�\�i��4��4��*��modules/import-export/processes/revert.phpnu��[�����������<?php
namespace Elementor\App\Modules\ImportExport\Processes;

use Elementor\App\Modules\ImportExport\Module;
use Elementor\App\Modules\ImportExport\Runners\Revert\Elementor_Content;
use Elementor\App\Modules\ImportExport\Runners\Revert\Revert_Runner_Base;
use Elementor\App\Modules\ImportExport\Runners\Revert\Plugins;
use Elementor\App\Modules\ImportExport\Runners\Revert\Site_Settings;
use Elementor\App\Modules\ImportExport\Runners\Revert\Taxonomies;
use Elementor\App\Modules\ImportExport\Runners\Revert\Templates;
use Elementor\App\Modules\ImportExport\Runners\Revert\Wp_Content;
use Elementor\App\Modules\ImportExport\Utils;

class Revert {

/**
	 * @var Revert_Runner_Base[]
	 */
	protected $runners = [];

private $import_sessions;

private $revert_sessions;

public function __construct() {
		$this->import_sessions = self::get_import_sessions();
		$this->revert_sessions = self::get_revert_sessions();
	}

/**
	 * Register a runner.
	 *
	 * @param Revert_Runner_Base $runner_instance
	 */
	public function register( Revert_Runner_Base $runner_instance ) {
		$this->runners[ $runner_instance::get_name() ] = $runner_instance;
	}

public function register_default_runners() {
		$this->register( new Site_Settings() );
		$this->register( new Plugins() );
		$this->register( new Templates() );
		$this->register( new Taxonomies() );
		$this->register( new Elementor_Content() );
		$this->register( new Wp_Content() );
	}

/**
	 * Execute the revert process.
	 *
	 * @throws \Exception If no revert runners have been specified.
	 */
	public function run() {
		if ( empty( $this->runners ) ) {
			throw new \Exception( 'Couldn’t execute the revert process because no revert runners have been specified. Try again by specifying revert runners.' );
		}

$import_session = $this->get_last_import_session();

if ( empty( $import_session ) ) {
			throw new \Exception( 'Couldn’t execute the revert process because there are no import sessions to revert.' );
		}

// fallback if the import session failed and doesn't have the runners metadata
		if ( ! isset( $import_session['runners'] ) && isset( $import_session['instance_data'] ) ) {
			$import_session['runners'] = $import_session['instance_data']['runners_import_metadata'] ?? [];
		}

foreach ( $this->runners as $runner ) {
			if ( $runner->should_revert( $import_session ) ) {
				$runner->revert( $import_session );
			}
		}

$this->revert_attachments( $import_session );

$this->delete_last_import_data();
	}

public static function get_import_sessions() {
		$import_sessions = Utils::get_import_sessions();

if ( ! $import_sessions ) {
			return [];
		}

usort( $import_sessions, function( $a, $b ) {
			return strcmp( $a['start_timestamp'], $b['start_timestamp'] );
		} );

return $import_sessions;
	}

public static function get_revert_sessions() {
		$revert_sessions = get_option( Module::OPTION_KEY_ELEMENTOR_REVERT_SESSIONS );

if ( ! $revert_sessions ) {
			return [];
		}

return $revert_sessions;
	}

public function get_last_import_session() {
		$import_sessions = $this->import_sessions;

if ( empty( $import_sessions ) ) {
			return [];
		}

return end( $import_sessions );
	}

public function get_penultimate_import_session() {
		$sessions_data = $this->import_sessions;
		$penultimate_element_value = [];

if ( empty( $sessions_data ) ) {
			return [];
		}

end( $sessions_data );

prev( $sessions_data );

if ( ! is_null( key( $sessions_data ) ) ) {
			$penultimate_element_value = current( $sessions_data );
		}

return $penultimate_element_value;
	}

private function delete_last_import_data() {
		$import_sessions = $this->import_sessions;
		$revert_sessions = $this->revert_sessions;

$reverted_session = array_pop( $import_sessions );

$revert_sessions[] = [
			'session_id' => $reverted_session['session_id'],
			'kit_title' => $reverted_session['kit_title'],
			'kit_name' => $reverted_session['kit_name'],
			'kit_thumbnail' => $reverted_session['kit_thumbnail'],
			'source' => $reverted_session['kit_source'],
			'user_id' => get_current_user_id(),
			'import_timestamp' => $reverted_session['start_timestamp'],
			'revert_timestamp' => current_time( 'timestamp' ),
		];

update_option( Module::OPTION_KEY_ELEMENTOR_IMPORT_SESSIONS, $import_sessions, false );
		update_option( Module::OPTION_KEY_ELEMENTOR_REVERT_SESSIONS, $revert_sessions, false );

$this->import_sessions = $import_sessions;
		$this->revert_sessions = $revert_sessions;
	}

private function revert_attachments( $data ) {
		$query_args = [
			'post_type' => 'attachment',
			'post_status' => 'any',
			'posts_per_page' => -1,
			'meta_query' => [
				[
					'key' => Module::META_KEY_ELEMENTOR_IMPORT_SESSION_ID,
					'value' => $data['session_id'],
				],
			],
		];

$query = new \WP_Query( $query_args );

foreach ( $query->posts as $post ) {
			wp_delete_attachment( $post->ID, true );
		}
	}
}
PK������,�\,{#|�`���`��*��modules/import-export/processes/import.phpnu��[�����������<?php

namespace Elementor\App\Modules\ImportExport\Processes;

use Elementor\App\Modules\ImportExport\Compatibility\Base_Adapter;
use Elementor\App\Modules\ImportExport\Compatibility\Envato;
use Elementor\App\Modules\ImportExport\Compatibility\Kit_Library;
use Elementor\App\Modules\ImportExport\Utils;
use Elementor\Core\Base\Document;
use Elementor\Core\Kits\Documents\Kit;
use Elementor\Plugin;

use Elementor\App\Modules\ImportExport\Runners\Import\Elementor_Content;
use Elementor\App\Modules\ImportExport\Runners\Import\Import_Runner_Base;
use Elementor\App\Modules\ImportExport\Runners\Import\Plugins;
use Elementor\App\Modules\ImportExport\Runners\Import\Site_Settings;
use Elementor\App\Modules\ImportExport\Runners\Import\Taxonomies;
use Elementor\App\Modules\ImportExport\Runners\Import\Templates;
use Elementor\App\Modules\ImportExport\Runners\Import\Wp_Content;
use Elementor\App\Modules\ImportExport\Module;

class Import {
	const MANIFEST_ERROR_KEY = 'manifest-error';

const ZIP_FILE_ERROR_KEY = 'invalid-zip-file';

const ZIP_ARCHIVE_ERROR_KEY = 'zip-archive-module-missing';

/**
	 * @var Import_Runner_Base[]
	 */
	protected $runners = [];

/**
	 * The session ID of the import process.
	 * This ID is uniquely generated for each import process (by the temp folder which contains the extracted kit files).
	 *
	 * @var string
	 */
	private $session_id;

/**
	 * The Kit ID.
	 *
	 * @var string
	 */
	private $kit_id;

/**
	 * Adapter for the kit compatibility.
	 *
	 * @var Base_Adapter[]
	 */
	private $adapters;

/**
	 * Document's data (elements and settings) that was imported during the process.
	 *
	 * @var array { [document_id] => { "elements": array , "settings": array } }
	 */
	private $documents_data = [];

/**
	 * Path to the extracted kit files.
	 *
	 * @var string
	 */
	private $extracted_directory_path;

/**
	 * Imported kit manifest.
	 *
	 * @var array
	 */
	private $manifest;

/**
	 * Imported kit site settings. (e.g: custom_colors, custom_typography, etc.)
	 *
	 * @var array
	 */
	private $site_settings;

/**
	 * Selected content types to import.
	 *
	 * @var array
	 */
	private $settings_include;

/**
	 * Referer of the import. (e.g: kit-library, local, etc.)
	 *
	 * @var string
	 */
	private $settings_referrer;

/**
	 * All the conflict between the exited templates and the kit templates.
	 *
	 * @var array
	 */
	private $settings_conflicts;

/**
	 * Selected elementor templates conditions to override.
	 *
	 * @var array
	 */
	private $settings_selected_override_conditions;

/**
	 * Selected custom post types to import.
	 *
	 * @var array
	 */
	private $settings_selected_custom_post_types;

/**
	 * Selected plugins to import.
	 *
	 * @var array
	 */
	private $settings_selected_plugins;

/**
	 * The imported data output.
	 *
	 * @var array
	 */
	private $imported_data = [];

/**
	 * The metadata output of the import runners.
	 * Will be saved in the import_session and will be used to revert the import process.
	 *
	 * @var array
	 */
	private $runners_import_metadata = [];

/**
	 * @param string     $path session_id | zip_file_path
	 * @param array      $settings Use to determine which content to import.
	 *                   (e.g: include, selected_plugins, selected_cpt, selected_override_conditions, etc.)
	 * @param array|null $old_instance An array of old instance parameters that will be used for creating new instance.
	 *                   We are using it for quick creation of the instance when the import process is being split into chunks.
	 *
	 * @throws \Exception If the import session does not exist.
	 */
	public function __construct( string $path, array $settings = [], array $old_instance = null ) {
		if ( ! empty( $old_instance ) ) {
			$this->set_import_object( $old_instance );
		} else {
			if ( is_file( $path ) ) {
				$this->extracted_directory_path = $this->extract_zip( $path );
			} else {
				$elementor_tmp_directory = Plugin::$instance->uploads_manager->get_temp_dir();
				$path = $elementor_tmp_directory . basename( $path );

if ( ! is_dir( $path ) ) {
					throw new \Exception( 'Couldn’t execute the import process because the import session does not exist.' );
				}

$this->extracted_directory_path = $path . '/';
			}

$this->session_id = basename( $this->extracted_directory_path );
			$this->kit_id = $settings['id'] ?? '';
			$this->settings_referrer = ! empty( $settings['referrer'] ) ? $settings['referrer'] : 'local';
			$this->settings_include = ! empty( $settings['include'] ) ? $settings['include'] : null;

// Using isset and not empty is important since empty array is valid option.
			$this->settings_selected_override_conditions = $settings['overrideConditions'] ?? null;
			$this->settings_selected_custom_post_types = $settings['selectedCustomPostTypes'] ?? null;
			$this->settings_selected_plugins = $settings['plugins'] ?? null;

$this->manifest = $this->read_manifest_json();
			$this->site_settings = $this->read_site_settings_json();

$this->set_default_settings();
		}

add_filter( 'wp_php_error_args', function ( $args, $error ) {
			return $this->filter_php_error_args( $args, $error );
		}, 10, 2 );
	}

/**
	 * Set the import object parameters.
	 *
	 * @param array $instance
	 * @return void
	 */
	private function set_import_object( array $instance ) {
		$this->session_id = $instance['session_id'];

$instance_data = $instance['instance_data'];

$this->extracted_directory_path = $instance_data['extracted_directory_path'];
		$this->runners = $instance_data['runners'];
		$this->adapters = $instance_data['adapters'];

$this->manifest = $instance_data['manifest'];
		$this->site_settings = $instance_data['site_settings'];

$this->settings_include = $instance_data['settings_include'];
		$this->settings_referrer = $instance_data['settings_referrer'];
		$this->settings_conflicts = $instance_data['settings_conflicts'];
		$this->settings_selected_override_conditions = $instance_data['settings_selected_override_conditions'];
		$this->settings_selected_custom_post_types = $instance_data['settings_selected_custom_post_types'];
		$this->settings_selected_plugins = $instance_data['settings_selected_plugins'];

$this->documents_data = $instance_data['documents_data'];
		$this->imported_data = $instance_data['imported_data'];
		$this->runners_import_metadata = $instance_data['runners_import_metadata'];
	}

/**
	 * Creating a new instance of the import process by the id of the old import session.
	 *
	 * @param string $session_id
	 *
	 * @return Import
	 * @throws \Exception If the import session does not exist.
	 */
	public static function from_session( string $session_id ): Import {
		$import_sessions = Utils::get_import_sessions();

if ( ! $import_sessions || ! isset( $import_sessions[ $session_id ] ) ) {
			throw new \Exception( 'Couldn’t execute the import process because the import session does not exist.' );
		}

$import_session = $import_sessions[ $session_id ];

return new self( $session_id, [], $import_session );
	}

/**
	 * Register a runner.
	 * Be aware that the runner will be executed in the order of registration, the order is crucial for the import process.
	 *
	 * @param Import_Runner_Base $runner_instance
	 */
	public function register( Import_Runner_Base $runner_instance ) {
		$this->runners[ $runner_instance::get_name() ] = $runner_instance;
	}

/**
	 * Set default settings for the import.
	 */
	private function set_default_settings() {
		if ( ! is_array( $this->get_settings_include() ) ) {
			$this->settings_include( $this->get_default_settings_include() );
		}

if ( ! is_array( $this->get_settings_conflicts() ) ) {
			$this->settings_conflicts( $this->get_default_settings_conflicts() );
		}

if ( ! is_array( $this->get_settings_selected_override_conditions() ) ) {
			$this->settings_selected_override_conditions( $this->get_default_settings_override_conditions() );
		}

if ( ! is_array( $this->get_settings_selected_custom_post_types() ) ) {
			$this->settings_selected_custom_post_types( $this->get_default_settings_custom_post_types() );
		}

if ( ! is_array( $this->get_settings_selected_plugins() ) ) {
			$this->settings_selected_plugins( $this->get_default_settings_plugins() );
		}
	}

/**
	 * Execute the import process.
	 *
	 * @return array The imported data output.
	 *
	 * @throws \Exception If no import runners have been specified.
	 */
	public function run() {
		if ( empty( $this->runners ) ) {
			throw new \Exception( 'Couldn’t execute the import process because no import runners have been specified. Try again by specifying import runners.' );
		}

$data = [
			'session_id' => $this->session_id,
			'include' => $this->settings_include,
			'manifest' => $this->manifest,
			'site_settings' => $this->site_settings,
			'selected_plugins' => $this->settings_selected_plugins,
			'extracted_directory_path' => $this->extracted_directory_path,
			'selected_custom_post_types' => $this->settings_selected_custom_post_types,
		];

$this->init_import_session();

remove_filter( 'elementor/document/save/data', [ Plugin::$instance->modules_manager->get_modules( 'content-sanitizer' ), 'sanitize_content' ] );
		add_filter( 'elementor/document/save/data', [ $this, 'prevent_saving_elements_on_post_creation' ], 10, 2 );

// Set the Request's state as an Elementor upload request, in order to support unfiltered file uploads.
		Plugin::$instance->uploads_manager->set_elementor_upload_state( true );

foreach ( $this->runners as $runner ) {
			if ( $runner->should_import( $data ) ) {
				$import = $runner->import( $data, $this->imported_data );
				$this->imported_data = array_merge_recursive( $this->imported_data, $import );

$this->runners_import_metadata[ $runner::get_name() ] = $runner->get_import_session_metadata();
			}
		}

// After the upload complete, set the elementor upload state back to false.
		Plugin::$instance->uploads_manager->set_elementor_upload_state( false );

remove_filter( 'elementor/document/save/data', [ $this, 'prevent_saving_elements_on_post_creation' ], 10 );

$this->finalize_import_session_option();

$this->save_elements_of_imported_posts();

Plugin::$instance->uploads_manager->remove_file_or_dir( $this->extracted_directory_path );
		return $this->imported_data;
	}

/**
	 * Run specific runner by runner_name
	 *
	 * @param string $runner_name
	 *
	 * @return array
	 *
	 * @throws \Exception If no export runners have been specified.
	 */
	public function run_runner( string $runner_name ): array {
		if ( empty( $this->runners ) ) {
			throw new \Exception( 'Couldn’t execute the import process because no import runners have been specified. Try again by specifying import runners.' );
		}

add_filter( 'elementor/document/save/data', [ $this, 'prevent_saving_elements_on_post_creation' ], 10, 2 );

// Set the Request's state as an Elementor upload request, in order to support unfiltered file uploads.
		Plugin::$instance->uploads_manager->set_elementor_upload_state( true );

$runner = $this->runners[ $runner_name ];

if ( empty( $runner ) ) {
			throw new \Exception( 'Couldn’t execute the import process because the import runner was not found. Try again by specifying an import runner.' );
		}

if ( $runner->should_import( $data ) ) {
			$import = $runner->import( $data, $this->imported_data );
			$this->imported_data = array_merge_recursive( $this->imported_data, $import );

$this->runners_import_metadata[ $runner::get_name() ] = $runner->get_import_session_metadata();
		}

// After the upload complete, set the elementor upload state back to false.
		Plugin::$instance->uploads_manager->set_elementor_upload_state( false );

remove_filter( 'elementor/document/save/data', [ $this, 'prevent_saving_elements_on_post_creation' ], 10 );

$is_last_runner = key( array_slice( $this->runners, -1, 1, true ) ) === $runner_name;
		if ( $is_last_runner ) {
			$this->finalize_import_session_option();
			$this->save_elements_of_imported_posts();
		} else {
			$this->update_instance_data_in_import_session_option();
		}

return [
			'status' => 'success',
			'runner' => $runner_name,
		];
	}

/**
	 * Create and save all the instance data to the import sessions option.
	 *
	 * @return void
	 */
	public function init_import_session( $save_instance_data = false ) {
		$import_sessions = Utils::get_import_sessions( true );

$import_sessions[ $this->session_id ] = [
			'session_id' => $this->session_id,
			'kit_title' => $this->manifest['title'] ?? '',
			'kit_name' => $this->manifest['name'] ?? '',
			'kit_thumbnail' => $this->get_kit_thumbnail(),
			'kit_source' => $this->settings_referrer,
			'user_id' => get_current_user_id(),
			'start_timestamp' => current_time( 'timestamp' ),
		];

if ( $save_instance_data ) {
			$import_sessions[ $this->session_id ]['instance_data'] = [
				'extracted_directory_path' => $this->extracted_directory_path,
				'runners' => $this->runners,
				'adapters' => $this->adapters,

'manifest' => $this->manifest,
				'site_settings' => $this->site_settings,

'settings_include' => $this->settings_include,
				'settings_referrer' => $this->settings_referrer,
				'settings_conflicts' => $this->settings_conflicts,
				'settings_selected_override_conditions' => $this->settings_selected_override_conditions,
				'settings_selected_custom_post_types' => $this->settings_selected_custom_post_types,
				'settings_selected_plugins' => $this->settings_selected_plugins,

'documents_data' => $this->documents_data,
				'imported_data' => $this->imported_data,
				'runners_import_metadata' => $this->runners_import_metadata,
			];
		}

update_option( Module::OPTION_KEY_ELEMENTOR_IMPORT_SESSIONS, $import_sessions, false );
	}

/**
	 * Get the Kit thumbnail, goes to the home page thumbnail if main doesn't exist
	 *
	 * @return string
	 */
	private function get_kit_thumbnail(): string {
		if ( ! empty( $this->manifest['thumbnail'] ) ) {
			return $this->manifest['thumbnail'];
		}

return apply_filters( 'elementor/import/kit_thumbnail', '', $this->kit_id, $this->settings_referrer );
	}

public function get_runners_name(): array {
		return array_keys( $this->runners );
	}

public function get_manifest() {
		return $this->manifest;
	}

public function get_extracted_directory_path() {
		return $this->extracted_directory_path;
	}

public function get_session_id() {
		return $this->session_id;
	}

public function get_adapters() {
		return $this->adapters;
	}

public function get_imported_data() {
		return $this->imported_data;
	}

/**
	 * Get settings by key.
	 * Used for backward compatibility.
	 *
	 * @param string $key The key of the setting.
	 */
	public function get_settings( $key ) {
		switch ( $key ) {
			case 'include':
				return $this->get_settings_include();

case 'overrideConditions':
				return $this->get_settings_selected_override_conditions();

case 'selectedCustomPostTypes':
				return $this->get_settings_selected_custom_post_types();

case 'plugins':
				return $this->get_settings_selected_plugins();

default:
				return [];
		}
	}

public function settings_include( array $settings_include ) {
		$this->settings_include = $settings_include;

return $this;
	}

public function get_settings_include() {
		return $this->settings_include;
	}

public function settings_referrer( $settings_referrer ) {
		$this->settings_referrer = $settings_referrer;

return $this;
	}

public function get_settings_referrer() {
		return $this->settings_referrer;
	}

public function settings_conflicts( array $settings_conflicts ) {
		$this->settings_conflicts = $settings_conflicts;

return $this;
	}

public function get_settings_conflicts() {
		return $this->settings_conflicts;
	}

public function settings_selected_override_conditions( array $settings_selected_override_conditions ) {
		$this->settings_selected_override_conditions = $settings_selected_override_conditions;

return $this;
	}

public function get_settings_selected_override_conditions() {
		return $this->settings_selected_override_conditions;
	}

public function settings_selected_custom_post_types( array $settings_selected_custom_post_types ) {
		$this->settings_selected_custom_post_types = $settings_selected_custom_post_types;

return $this;
	}

public function get_settings_selected_custom_post_types() {
		return $this->settings_selected_custom_post_types;
	}

public function settings_selected_plugins( array $settings_selected_plugins ) {
		$this->settings_selected_plugins = $settings_selected_plugins;

return $this;
	}

public function get_settings_selected_plugins() {
		return $this->settings_selected_plugins;
	}

/**
	 * Prevent saving elements on elementor post creation.
	 *
	 * @param array    $data
	 * @param Document $document
	 *
	 * @return array
	 */
	public function prevent_saving_elements_on_post_creation( array $data, Document $document ) {
		if ( isset( $data['elements'] ) ) {
			$this->documents_data[ $document->get_main_id() ] = [ 'elements' => $data['elements'] ];

$data['elements'] = [];
		}

if ( isset( $data['settings'] ) ) {
			$this->documents_data[ $document->get_main_id() ]['settings'] = $data['settings'];

}

return $data;
	}

/**
	 * Extract the zip file.
	 *
	 * @param string $zip_path The path to the zip file.
	 * @return string The extracted directory path.
	 * @throws \Error If import process fails, file validation errors occur, or data corruption is detected.
	 */
	private function extract_zip( $zip_path ) {
		$extraction_result = Plugin::$instance->uploads_manager->extract_and_validate_zip( $zip_path, [ 'json', 'xml' ] );

if ( is_wp_error( $extraction_result ) ) {
			if ( isset( $extraction_result->errors['zip_error'] ) ) {
				throw new \Error( static::ZIP_ARCHIVE_ERROR_KEY ); // phpcs:ignore WordPress.Security.EscapeOutput.ExceptionNotEscaped
			}

throw new \Error( static::ZIP_FILE_ERROR_KEY ); // phpcs:ignore WordPress.Security.EscapeOutput.ExceptionNotEscaped
		}

return $extraction_result['extraction_directory'];
	}

/**
	 * Get the manifest file from the extracted directory and adapt it if needed.
	 *
	 * @return string The manifest file content.
	 *
	 * @throws \Error If import validation fails or processing errors occur.
	 */
	private function read_manifest_json() {
		$manifest = Utils::read_json_file( $this->extracted_directory_path . 'manifest' );

if ( ! $manifest ) {
			Plugin::$instance->logger->get_logger()->error( static::MANIFEST_ERROR_KEY );
			throw new \Error( static::ZIP_FILE_ERROR_KEY ); // phpcs:ignore WordPress.Security.EscapeOutput.ExceptionNotEscaped
		}

$this->init_adapters( $manifest );

foreach ( $this->adapters as $adapter ) {
			$manifest = $adapter->adapt_manifest( $manifest );
		}

return $manifest;
	}

/**
	 * Init the adapters and determine which ones to use.
	 *
	 * @param array $manifest_data The manifest file content.
	 */
	private function init_adapters( array $manifest_data ) {
		$this->adapters = [];

/** @var Base_Adapter[] $adapter_types */
		$adapter_types = [ Envato::class, Kit_Library::class ];

foreach ( $adapter_types as $adapter_type ) {
			if ( $adapter_type::is_compatibility_needed( $manifest_data, [ 'referrer' => $this->get_settings_referrer() ] ) ) {
				$this->adapters[] = new $adapter_type( $this );
			}
		}
	}

/**
	 * Get the site settings file from the extracted directory and adapt it if needed.
	 *
	 * @return string The site settings file content.
	 */
	private function read_site_settings_json() {
		$site_settings = Utils::read_json_file( $this->extracted_directory_path . 'site-settings' );

foreach ( $this->adapters as $adapter ) {
			$site_settings = $adapter->adapt_site_settings( $site_settings, $this->manifest, $this->extracted_directory_path );
		}

return $site_settings;
	}

/**
	 * Get all the custom post types in the kit.
	 *
	 * @return array Custom post types names.
	 */
	private function get_default_settings_custom_post_types() {
		if ( empty( $this->manifest['custom-post-type-title'] ) ) {
			return [];
		}

$manifest_post_types = array_keys( $this->manifest['custom-post-type-title'] );

return array_diff( $manifest_post_types, Utils::get_builtin_wp_post_types() );
	}

/**
	 * Get the default settings of elementor templates conditions to override.
	 *
	 * @return array
	 */
	private function get_default_settings_conflicts() {
		if ( empty( $this->manifest['templates'] ) ) {
			return [];
		}

return apply_filters( 'elementor/import/get_default_settings_conflicts', [], $this->manifest['templates'] );
	}

/**
	 * Get the default settings of elementor templates conditions to override.
	 *
	 * @return array
	 */
	private function get_default_settings_override_conditions() {
		if ( empty( $this->settings_conflicts ) ) {
			return [];
		}

return array_keys( $this->settings_conflicts );
	}

/**
	 * Get the default settings of the plugins that should be imported.
	 *
	 * @return array
	 */
	private function get_default_settings_plugins() {
		return ! empty( $this->manifest['plugins'] ) ? $this->manifest['plugins'] : [];
	}

/**
	 * Get the default settings of which content types should be imported.
	 *
	 * @return array
	 */
	private function get_default_settings_include() {
		return [ 'templates', 'plugins', 'content', 'settings' ];
	}

/**
	 * Get the data that requires updating/replacement when imported.
	 *
	 * @return array{post_ids: array, term_ids: array}
	 */
	private function get_imported_data_replacements(): array {
		return [
			'post_ids' => Utils::map_old_new_post_ids( $this->imported_data ),
			'term_ids' => Utils::map_old_new_term_ids( $this->imported_data ),
		];
	}

/**
	 * Save the prevented elements on elementor post creation elements.
	 * Handle the replacement of all the dynamic content of the elements that probably have been changed during the import.
	 */
	private function save_elements_of_imported_posts() {
		$imported_data_replacements = $this->get_imported_data_replacements();

foreach ( $this->documents_data as $new_id => $data ) {
			$document = Plugin::$instance->documents->get( $new_id );

if ( isset( $data['elements'] ) ) {
				$data['elements'] = $document->on_import_update_dynamic_content( $data['elements'], $imported_data_replacements );
			}

if ( isset( $data['settings'] ) ) {

if ( $document instanceof Kit ) {
					// Without post_status certain tabs in the Kit will not save properly.
					$data['settings']['post_status'] = get_post_status( $new_id );
				}

$data['settings'] = $document->on_import_update_settings( $data['settings'], $imported_data_replacements );
			}

$document->save( $data );
		}
	}

private function update_instance_data_in_import_session_option() {
		$import_sessions = Utils::get_import_sessions();

$import_sessions[ $this->session_id ]['instance_data']['documents_data'] = $this->documents_data;
		$import_sessions[ $this->session_id ]['instance_data']['imported_data'] = $this->imported_data;
		$import_sessions[ $this->session_id ]['instance_data']['runners_import_metadata'] = $this->runners_import_metadata;

update_option( Module::OPTION_KEY_ELEMENTOR_IMPORT_SESSIONS, $import_sessions, false );
	}

public function finalize_import_session_option() {
		$import_sessions = Utils::get_import_sessions();

if ( ! isset( $import_sessions[ $this->session_id ] ) ) {
			return;
		}

unset( $import_sessions[ $this->session_id ]['instance_data'] );

$import_sessions[ $this->session_id ]['end_timestamp'] = current_time( 'timestamp' );
		$import_sessions[ $this->session_id ]['runners'] = $this->runners_import_metadata;

update_option( Module::OPTION_KEY_ELEMENTOR_IMPORT_SESSIONS, $import_sessions, false );
	}

/**
	 * Filter the php error args and return 408 status code if the error is a timeout.
	 *
	 * @param array $args
	 * @param array $error
	 * @return array
	 */
	private function filter_php_error_args( $args, $error ) {
		if ( strpos( $error['message'], 'Maximum execution time' ) !== false ) {
			$args['response'] = 408;
		}

return $args;
	}
}
PK������,�\v�夼$���$��*��modules/import-export/processes/export.phpnu��[�����������<?php

namespace Elementor\App\Modules\ImportExport\Processes;

use Elementor\App\Modules\ImportExport\Module;
use Elementor\App\Modules\ImportExport\Utils;
use Elementor\Core\Utils\Str;
use Elementor\Plugin;

use Elementor\App\Modules\ImportExport\Runners\Export\Elementor_Content;
use Elementor\App\Modules\ImportExport\Runners\Export\Export_Runner_Base;
use Elementor\App\Modules\ImportExport\Runners\Export\Plugins;
use Elementor\App\Modules\ImportExport\Runners\Export\Site_Settings;
use Elementor\App\Modules\ImportExport\Runners\Export\Taxonomies;
use Elementor\App\Modules\ImportExport\Runners\Export\Templates;
use Elementor\App\Modules\ImportExport\Runners\Export\Wp_Content;

class Export {
	const ZIP_ARCHIVE_MODULE_MISSING = 'zip-archive-module-is-missing';

/**
	 * @var Export_Runner_Base[]
	 */
	protected $runners = [];

/**
	 * Selected content types to export.
	 *
	 * @var array
	 */
	private $settings_include;

/**
	 * The kit information. (e.g: title, description)
	 *
	 * @var array $export_data
	 */
	private $settings_kit_info;

/**
	 * Selected plugins to export.
	 * Contains the plugins essential data for export. (e.g: name, path, version, etc.)
	 *
	 * @var array
	 */
	private $settings_selected_plugins;

/**
	 * Selected custom post types to export.
	 *
	 * @var array
	 */
	private $settings_selected_custom_post_types;

/**
	 * The output data of the export process.
	 * Will be written into the manifest.json file.
	 *
	 * @var array
	 */
	private $manifest_data;

/**
	 * The zip archive object.
	 *
	 * @var \ZipArchive
	 */
	private $zip;

public function __construct( $settings = [] ) {
		$this->settings_include = ! empty( $settings['include'] ) ? $settings['include'] : null;
		$this->settings_kit_info = ! empty( $settings['kitInfo'] ) ? $settings['kitInfo'] : null;
		$this->settings_selected_plugins = isset( $settings['plugins'] ) ? $settings['plugins'] : null;
		$this->settings_selected_custom_post_types = isset( $settings['selectedCustomPostTypes'] ) ? $settings['selectedCustomPostTypes'] : null;
	}

/**
	 * Register a runner.
	 *
	 * @param Export_Runner_Base $runner_instance
	 */
	public function register( Export_Runner_Base $runner_instance ) {
		$this->runners[ $runner_instance::get_name() ] = $runner_instance;
	}

/**
	 * Execute the export process.
	 *
	 * @return array The export data output.
	 *
	 * @throws \Exception If no export runners have been specified.
	 */
	public function run() {
		if ( empty( $this->runners ) ) {
			throw new \Exception( 'Couldn’t execute the export process because no export runners have been specified. Try again by specifying export runners.' );
		}

$this->set_default_settings();

$this->init_zip_archive();
		$this->init_manifest_data();

$data = [
			'include' => $this->settings_include,
			'selected_plugins' => $this->settings_selected_plugins,
			'selected_custom_post_types' => $this->settings_selected_custom_post_types,
		];

foreach ( $this->runners as $runner ) {
			if ( $runner->should_export( $data ) ) {
				$export_result = $runner->export( $data );
				$this->handle_export_result( $export_result );
			}
		}

$this->add_json_file( 'manifest', $this->manifest_data );

$zip_file_name = $this->zip->filename;
		$this->zip->close();

return [
			'manifest' => $this->manifest_data,
			'file_name' => $zip_file_name,
		];
	}

/**
	 * Set default settings for the export.
	 */
	private function set_default_settings() {
		if ( ! is_array( $this->get_settings_include() ) ) {
			$this->settings_include( $this->get_default_settings_include() );
		}

if ( ! is_array( $this->get_settings_kit_info() ) ) {
			$this->settings_kit_info( $this->get_default_settings_kit_info() );
		}

if ( ! is_array( $this->get_settings_selected_custom_post_types() ) && in_array( 'content', $this->settings_include, true ) ) {
			$this->settings_selected_custom_post_types( $this->get_default_settings_custom_post_types() );
		}

if ( ! is_array( $this->get_settings_selected_plugins() ) && in_array( 'plugins', $this->settings_include, true ) ) {
			$this->settings_selected_plugins( $this->get_default_settings_selected_plugins() );
		}
	}

public function settings_include( $included_settings ) {
		$this->settings_include = $included_settings;
	}

public function get_settings_include() {
		return $this->settings_include;
	}

private function settings_kit_info( $kit_info ) {
		$this->settings_kit_info = $kit_info;
	}

private function get_settings_kit_info() {
		return $this->settings_kit_info;
	}

public function settings_selected_custom_post_types( $selected_custom_post_types ) {
		$this->settings_selected_custom_post_types = $selected_custom_post_types;
	}

public function get_settings_selected_custom_post_types() {
		return $this->settings_selected_custom_post_types;
	}

public function settings_selected_plugins( $plugins ) {
		$this->settings_selected_plugins = $plugins;
	}

public function get_settings_selected_plugins() {
		return $this->settings_selected_plugins;
	}

/**
	 * Get the default settings of which content types should be exported.
	 *
	 * @return array
	 */
	private function get_default_settings_include() {
		return [ 'templates', 'content', 'settings', 'plugins' ];
	}

/**
	 * Get the default settings of the kit info.
	 *
	 * @return array
	 */
	private function get_default_settings_kit_info() {
		return [
			'title' => 'kit',
			'description' => '',
		];
	}

/**
	 * Get the default settings of the plugins that should be exported.
	 *
	 * @return array{name: string, plugin:string, pluginUri: string, version: string}
	 */
	private function get_default_settings_selected_plugins() {
		$installed_plugins = Plugin::$instance->wp->get_plugins();

return $installed_plugins->map( function ( $item, $key ) {
			return [
				'name' => $item['Name'],
				'plugin' => $key,
				'pluginUri' => $item['PluginURI'],
				'version' => $item['Version'],
			];
		} )->all();
	}

/**
	 * Get the default settings of all the custom post types that should be exported.
	 * Should be all the custom post types that are not built in to WordPress and not part of Elementor.
	 *
	 * @return array
	 */
	private function get_default_settings_custom_post_types() {
		return Utils::get_registered_cpt_names();
	}

/**
	 * Init the zip archive.
	 *
	 * @throws \Error If export process fails, file creation errors occur, or data serialization fails.
	 */
	private function init_zip_archive() {
		if ( ! class_exists( '\ZipArchive' ) ) {
			throw new \Error( static::ZIP_ARCHIVE_MODULE_MISSING ); // phpcs:ignore WordPress.Security.EscapeOutput.ExceptionNotEscaped
		}

$zip = new \ZipArchive();

$temp_dir = Plugin::$instance->uploads_manager->create_unique_dir();

$zip_file_name = $temp_dir . sanitize_title( $this->settings_kit_info['title'] ) . '.zip';

$zip->open( $zip_file_name, \ZipArchive::CREATE | \ZipArchive::OVERWRITE );

$this->zip = $zip;
	}

/**
	 * Init the manifest data and add some basic info to it.
	 */
	private function init_manifest_data() {
		$kit_post = Plugin::$instance->kits_manager->get_active_kit()->get_post();

$manifest_data = [
			'name' => sanitize_title( $this->settings_kit_info['title'] ),
			'title' => $this->settings_kit_info['title'],
			'description' => $this->settings_kit_info['description'],
			'author' => get_the_author_meta( 'display_name', $kit_post->post_author ),
			'version' => Module::FORMAT_VERSION,
			'elementor_version' => ELEMENTOR_VERSION,
			'created' => gmdate( 'Y-m-d H:i:s' ),
			'thumbnail' => get_the_post_thumbnail_url( $kit_post ),
			'site' => get_site_url(),
		];

$this->manifest_data = $manifest_data;
	}

/**
	 * Handle the export process output.
	 * Add the manifest data from the runner to the manifest.json file.
	 * Create files according to the files array that should be exported by the runner.
	 *
	 * @param array $export_result
	 */
	private function handle_export_result( $export_result ) {
		foreach ( $export_result['manifest'] as $data ) {
			$this->manifest_data += $data;
		}

if ( isset( $export_result['files']['path'] ) ) {
			$export_result['files'] = [ $export_result['files'] ];
		}

foreach ( $export_result['files'] as $file ) {
			$file_extension = pathinfo( $file['path'], PATHINFO_EXTENSION );
			if ( empty( $file_extension ) ) {
				$this->add_json_file(
					$file['path'],
					$file['data']
				);
			} else {
				$this->add_file(
					$file['path'],
					$file['data']
				);
			}
		}
	}

/**
	 * Add json file to the zip archive.
	 *
	 * @param string $path The relative path to the file.
	 * @param array  $content The content of the file.
	 * @param int    $json_flags
	 */
	private function add_json_file( $path, array $content, $json_flags = 0 ) {
		if ( ! Str::ends_with( $path, '.json' ) ) {
			$path .= '.json';
		}

$this->add_file( $path, wp_json_encode( $content, $json_flags ) );
	}

/**
	 * Add file to the zip archive.
	 *
	 * @param string $file
	 * @param string $content The content of the file.
	 */
	private function add_file( $file, $content ) {
		$this->zip->addFromString( $file, $content );
	}
}
PK������,�\?�s�������.��modules/import-export-customization/wp-cli.phpnu��[�����������<?php
namespace Elementor\App\Modules\ImportExportCustomization;

use Elementor\Core\Utils\Collection;
use Elementor\Core\Utils\Plugins_Manager;
use Elementor\Plugin;
use Elementor\App\Modules\KitLibrary\Connect\Kit_Library;

if ( ! defined( 'ABSPATH' ) ) {
	exit; // Exit if accessed directly.
}

class Wp_Cli extends \WP_CLI_Command {

const AVAILABLE_SETTINGS = [ 'include', 'overrideConditions', 'selectedCustomPostTypes', 'plugins' ];

\WP_CLI::line( 'Kit export started.' );

$export_settings = [];
		foreach ( $assoc_args as $key => $value ) {
			if ( ! in_array( $key, static::AVAILABLE_SETTINGS, true ) ) {
				continue;
			}

$export_settings[ $key ] = explode( ',', $value );
		}

rename( $result['file_name'], $args[0] );
		} catch ( \Error | \Exception $error ) {
			\WP_CLI::error( $error->getMessage() );
		}

\WP_CLI::success( 'Kit exported successfully.' );
	}

if ( empty( $args[0] ) ) {
			\WP_CLI::error( 'Please specify a file to import' );
		}

\WP_CLI::line( 'Kit import started' );

$assoc_args = wp_parse_args( $assoc_args, [
			'sourceType' => 'local',
		] );

$url = null;
		$file_path = $args[0];
		$import_settings = [];
		$import_settings['referrer'] = Module::REFERRER_LOCAL;

case 'remote':
				$zip_path = $this->create_temp_file_from_url( $file_path );
				break;

case 'local':
				$zip_path = $file_path;
				break;

default:
				\WP_CLI::error( 'Unknown source type.' );
				break;
		}

if ( 'enable' === $assoc_args['unfilteredFilesUpload'] ) {
			Plugin::$instance->uploads_manager->enable_unfiltered_files_upload();
		}

foreach ( $assoc_args as $key => $value ) {
			if ( ! in_array( $key, static::AVAILABLE_SETTINGS, true ) ) {
				continue;
			}

$import_settings[ $key ] = explode( ',', $value );
		}

try {
			\WP_CLI::line( 'Importing data...' );

if ( ! $import_export_module ) {
				\WP_CLI::error( 'Import Export module is not available.' );
			}

$import = $import_export_module->import_kit( $zip_path, $import_settings );

$manifest_data = $import_export_module->import->get_manifest();

\WP_CLI::line( 'Removing temp files...' );

// The file was created from remote or library request, it also should be removed.
			if ( $url ) {
				Plugin::$instance->uploads_manager->remove_file_or_dir( dirname( $zip_path ) );
			}

\WP_CLI::success( 'Kit imported successfully' );
		} catch ( \Error | \Exception $error ) {
			Plugin::$instance->logger->get_logger()->error( $error->getMessage(), [
				'meta' => [
					'trace' => $error->getTraceAsString(),
				],
			] );

if ( $url ) {
				Plugin::$instance->uploads_manager->remove_file_or_dir( dirname( $zip_path ) );
			}

\WP_CLI::error( $error->getMessage() );
		}
	}

/**
	 * Revert last imported kit.
	 */
	public function revert() {
		\WP_CLI::line( 'Kit revert started.' );

} catch ( \Error | \Exception $error ) {
			\WP_CLI::error( $error->getMessage() );
		}

\WP_CLI::success( 'Kit reverted successfully.' );
	}

if ( ! $app ) {
			\WP_CLI::error( 'Kit library app not found' );
		}

$response = $app->download_link( $kit_id );

if ( is_wp_error( $response ) ) {
			\WP_CLI::error( "Library Response: {$response->get_error_message()}" );
		}

return $response->download_link;
	}

if ( is_wp_error( $response ) ) {
			\WP_CLI::error( "Download file url: {$response->get_error_message()}" );
		}

if ( 200 !== $response['response']['code'] ) {
			\WP_CLI::error( "Download file url: {$response['response']['message']}" );
		}

// Set the Request's state as an Elementor upload request, in order to support unfiltered file uploads.
		Plugin::$instance->uploads_manager->set_elementor_upload_state( true );

$file = Plugin::$instance->uploads_manager->create_temp_file( $response['body'], 'kit.zip' );

// After the upload complete, set the elementor upload state back to false.
		Plugin::$instance->uploads_manager->set_elementor_upload_state( false );

return $file;
	}
}
PK������,�\�������A��modules/import-export-customization/runners/export/taxonomies.phpnu��[�����������<?php
namespace Elementor\App\Modules\ImportExportCustomization\Runners\Export;

use Elementor\App\Modules\ImportExportCustomization\Utils as ImportExportUtils;

class Taxonomies extends Export_Runner_Base {

public static function get_name(): string {
		return 'taxonomies';
	}

public function should_export( array $data ) {
		return (
			isset( $data['include'] ) &&
			in_array( 'content', $data['include'], true )
		);
	}

public function export( array $data ) {
		$customization = $data['customization']['content'] ?? null;
		if ( $customization ) {
			return $this->export_customization( $data, $customization );
		}

return $this->export_all( $data );
	}

public function export_customization( array $data, array $customization ) {
		$result = apply_filters( 'elementor/import-export-customization/export/taxonomies/customization', null, $data, $customization, $this );

if ( is_array( $result ) ) {
			return $result;
		}

return $this->export_all( $data );
	}

public function export_all( array $data ) {
		$selected_custom_post_types = $data['customization']['content']['customPostTypes'] ?? null;
		$exclude_post_types = [];

if ( is_array( $selected_custom_post_types ) && ! in_array( 'post', $selected_custom_post_types, true ) ) {
			$exclude_post_types[] = 'post';
		}

$wp_builtin_post_types = ImportExportUtils::get_builtin_wp_post_types( $exclude_post_types );

$post_types = is_array( $selected_custom_post_types )
			? array_merge( $wp_builtin_post_types, $selected_custom_post_types )
			: $wp_builtin_post_types;

$export = $this->export_taxonomies( $post_types );

$manifest_data['taxonomies'] = $export['manifest'];

return [
			'files' => $export['files'],
			'manifest' => [
				$manifest_data,
			],
		];
	}

private function export_taxonomies( array $post_types ) {
		$files = [];
		$manifest = [];

$taxonomies = get_taxonomies();

foreach ( $taxonomies as $taxonomy ) {
			$taxonomy_obj = get_taxonomy( $taxonomy );
			$taxonomy_post_types = $taxonomy_obj->object_type;
			$intersected_post_types = array_intersect( $taxonomy_post_types, $post_types );

if ( empty( $intersected_post_types ) ) {
				continue;
			}

$data = $this->export_terms( $taxonomy );

if ( empty( $data ) ) {
				continue;
			}

foreach ( $intersected_post_types as $post_type ) {
				$manifest[ $post_type ][] = [
					'name'  => $taxonomy,
					'label' => $taxonomy_obj->label,
				];
			}

$files[] = [
				'path' => 'taxonomies/' . $taxonomy,
				'data' => $data,
			];
		}

return [
			'files' => $files,
			'manifest' => $manifest,
		];
	}

public function export_terms( $taxonomy ) {
		$terms = get_terms( [
			'taxonomy' => (array) $taxonomy,
			'hide_empty' => false,
			'get' => 'all',
		] );

$ordered_terms = $this->order_terms( $terms );

if ( empty( $ordered_terms ) ) {
			return [];
		}

$data = [];

return $data;
	}
	/**
	 * Put terms in order with no child going before its parent.
	 */
	private function order_terms( array $terms ) {
		$ordered_terms = [];

while ( $term = array_shift( $terms ) ) {
			$is_top_level = 0 === $term->parent;
			$is_parent_exits = isset( $ordered_terms[ $term->parent ] );

if ( $is_top_level || $is_parent_exits ) {
				$ordered_terms[ $term->term_id ] = $term;
			} else {
				$terms[] = $term;
			}
		}

return $ordered_terms;
	}
}
PK������,�\��z^������I��modules/import-export-customization/runners/export/export-runner-base.phpnu��[�����������<?php

namespace Elementor\App\Modules\ImportExportCustomization\Runners\Export;

use Elementor\App\Modules\ImportExportCustomization\Runners\Runner_Interface;

abstract class Export_Runner_Base implements Runner_Interface {

/**
	 * Main function of the runner export process.
	 *
	 * @param array $data Necessary data for the export process.
	 *
	 * @return array{files: array, manifest: array}
	 * The files that should be part of the kit and the relevant manifest data.
	 */
	abstract public function export( array $data );
}
PK������,�\a��'����>��modules/import-export-customization/runners/export/plugins.phpnu��[�����������<?php

namespace Elementor\App\Modules\ImportExportCustomization\Runners\Export;

use Elementor\Core\Utils\Collection;

class Plugins extends Export_Runner_Base {

public static function get_name(): string {
		return 'plugins';
	}

public function should_export( array $data ) {
		return (
			isset( $data['include'] ) &&
			in_array( 'plugins', $data['include'], true ) &&
			is_array( $data['selected_plugins'] )
		);
	}

public function export( array $data ) {
		$customization = $data['customization']['plugins'] ?? null;

if ( $customization ) {
			$enabled_plugin_keys = Collection::make( $customization )->filter()->keys();

$plugins = Collection::make( $data['selected_plugins'] )
				->filter( function( $plugin_data, $plugin_key ) use ( $enabled_plugin_keys ) {
					return $enabled_plugin_keys->contains( $plugin_key );
				} )
				->all();
		} else {
			$plugins = $data['selected_plugins'];
		}

return [
			'manifest' => [
				[ 'plugins' => array_values( $plugins ) ],
			],
			'files' => [],
		];
	}
}
PK������,�\��h�����H��modules/import-export-customization/runners/export/elementor-content.phpnu��[�����������<?php

namespace Elementor\App\Modules\ImportExportCustomization\Runners\Export;

use Elementor\App\Modules\ImportExportCustomization\Utils as ImportExportUtils;
use Elementor\Plugin;

class Elementor_Content extends Export_Runner_Base {
	private $page_on_front_id;

public function __construct() {
		$this->init_page_on_front_data();
	}

public static function get_name(): string {
		return 'elementor-content';
	}

public function should_export( array $data ) {
		return (
			isset( $data['include'] ) &&
			in_array( 'content', $data['include'], true )
		);
	}

public function export( array $data ) {
		$customization = $data['customization']['content'] ?? null;
		$selected_custom_post_types = $data['selected_custom_post_types'] ?? null;
		$excluded_post_types = [];

if ( $selected_custom_post_types && ! in_array( 'post', $selected_custom_post_types, true ) ) {
			$excluded_post_types[] = 'post';
		}

$elementor_post_types = ImportExportUtils::get_elementor_post_types( $excluded_post_types );

$elementor_post_types = apply_filters( 'elementor/import-export-customization/elementor-content/post-types/customization', $elementor_post_types, $customization );

$files = [];
		$manifest = [];

foreach ( $elementor_post_types as $post_type ) {
			$export = $this->export_elementor_post_type( $post_type, $customization );
			$files = array_merge( $files, $export['files'] );

$manifest[ $post_type ] = $export['manifest_data'];
		}

$manifest_data['content'] = $manifest;

return [
			'files' => $files,
			'manifest' => [
				$manifest_data,
			],
		];
	}

private function export_elementor_post_type( $post_type, $customization ) {
		$manifest_data = [];
		$files = [];

$query_args = [
			'post_type' => $post_type,
			'post_status' => 'publish',
			'posts_per_page' => -1,
			'meta_query' => [
				[
					'key' => static::META_KEY_ELEMENTOR_EDIT_MODE,
					'compare' => 'EXISTS',
				],
				[
					'key' => '_elementor_data',
					'compare' => 'EXISTS',
				],
				[
					'key' => '_elementor_data',
					'compare' => '!=',
					'value' => '[]',
				],
			],
		];

$query_args = apply_filters( 'elementor/import-export-customization/export/elementor-content/query-args/customization', $query_args, $post_type, $customization );

$query = new \WP_Query( $query_args );

if ( empty( $query ) ) {
			return [
				'files' => [],
				'manifest_data' => [],
			];
		}

$post_type_taxonomies = $this->get_post_type_taxonomies( $post_type );

foreach ( $query->posts as $post ) {
			$document = Plugin::$instance->documents->get( $post->ID );

$terms = ! empty( $post_type_taxonomies ) ? $this->get_post_terms( $post->ID, $post_type_taxonomies ) : [];

if ( isset( $post->post_parent ) && $post->post_parent > 0 ) {
				$post_manifest_data['post_parent'] = $post->post_parent;
			}

if ( $post->ID === $this->page_on_front_id ) {
				$post_manifest_data['show_on_front'] = true;
			}

$manifest_data[ $post->ID ] = $post_manifest_data;

$files[] = [
				'path' => 'content/' . $post_type . '/' . $post->ID,
				'data' => $document->get_export_data(),
			];
		}

return [
			'files' => $files,
			'manifest_data' => $manifest_data,
		];
	}

private function get_post_type_taxonomies( $post_type ) {
		return get_object_taxonomies( $post_type );
	}

private function get_post_terms( $post_id, array $taxonomies ) {
		$terms = wp_get_object_terms( $post_id, $taxonomies );

$result = [];

foreach ( $terms as $term ) {
			$result[] = [
				'term_id' => $term->term_id,
				'taxonomy' => $term->taxonomy,
				'slug' => $term->slug,
			];
		}

return $result;
	}

private function init_page_on_front_data() {
		$show_page_on_front = 'page' === get_option( 'show_on_front' );

if ( $show_page_on_front ) {
			$this->page_on_front_id = (int) get_option( 'page_on_front' );
		}
	}
}
PK������,�\^�x�������D��modules/import-export-customization/runners/export/site-settings.phpnu��[�����������<?php
namespace Elementor\App\Modules\ImportExportCustomization\Runners\Export;

use Elementor\Modules\AtomicWidgets\Module as Atomic_Widgets_Module;
use Elementor\Modules\GlobalClasses\Module as Global_Classes_Module;
use Elementor\Modules\Variables\Module as Variables_Module;
use Elementor\Plugin;

class Site_Settings extends Export_Runner_Base {
	const ALLOWED_SETTINGS = [
		'theme',
		'globalColors',
		'globalFonts',
		'themeStyleSettings',
		'generalSettings',
		'experiments',
		'customCode',
		'customIcons',
		'customFonts',
		'classes',
		'variables',
	];

public static function get_name(): string {
		return 'site-settings';
	}

public function should_export( array $data ) {
		return (
			isset( $data['include'] ) &&
			in_array( 'settings', $data['include'], true )
		);
	}

public function export( array $data ) {
		$customization = $data['customization']['settings'] ?? null;
		if ( $customization ) {
			return $this->export_customization( $data, $customization );
		}

return $this->export_all( $data );
	}

private function export_all( $data, $include_theme = true ) {
		$kit = Plugin::$instance->kits_manager->get_active_kit();
		$kit_data = $kit->get_export_data();

$excluded_kit_settings_keys = [
			'site_name',
			'site_description',
			'site_logo',
			'site_favicon',
		];

foreach ( $excluded_kit_settings_keys as $setting_key ) {
			unset( $kit_data['settings'][ $setting_key ] );
		}

if ( $include_theme ) {
			$theme_data = $this->export_theme();

if ( $theme_data ) {
				$kit_data['theme'] = $theme_data;
				$manifest_data['theme'] = $theme_data;
			}
		}

$experiments_data = $this->export_experiments();

if ( $experiments_data ) {
			$kit_data['experiments'] = $experiments_data;
			$manifest_data['experiments'] = array_keys( $experiments_data );
		}

$manifest_data['site-settings'] = array_fill_keys( self::ALLOWED_SETTINGS, true );

if ( ! $include_theme ) {
			$manifest_data['site-settings']['theme'] = false;
		}

if ( $this->is_classes_feature_active() ) {
			$manifest_data['site-settings']['classesCount'] = $this->get_classes_count();
		} else {
			unset( $manifest_data['site-settings']['classes'] );
		}

if ( $this->is_variables_feature_active() ) {
			$manifest_data['site-settings']['variablesCount'] = $this->get_variables_count();
		} else {
			unset( $manifest_data['site-settings']['variables'] );
		}

return [
			'files' => [
				'path' => 'site-settings',
				'data' => $kit_data,
			],
			'manifest' => [
				$manifest_data,
			],
		];
	}

public function get_classes_count(): int {
		$kit = Plugin::$instance->kits_manager->get_active_kit();

if ( ! $kit ) {
			return 0;
		}

return count( \Elementor\Modules\GlobalClasses\Global_Classes_Order::make( $kit )->set_preview( false )->get_order() );
	}

public function get_variables_count(): int {
		$kit = Plugin::$instance->kits_manager->get_active_kit();
		$variables_repository = new \Elementor\Modules\Variables\Storage\Variables_Repository( $kit );
		$collection = $variables_repository->load();
		$count = 0;

foreach ( $collection->all() as $variable ) {
			if ( ! $variable->is_deleted() ) {
				++$count;
			}
		}

return $count;
	}

public function is_classes_feature_active(): bool {
		return Plugin::$instance->experiments->is_feature_active( Global_Classes_Module::NAME )
			&& Plugin::$instance->experiments->is_feature_active( Atomic_Widgets_Module::EXPERIMENT_NAME );
	}

public function is_variables_feature_active(): bool {
		return Plugin::$instance->experiments->is_feature_active( Variables_Module::EXPERIMENT_NAME )
			&& Plugin::$instance->experiments->is_feature_active( Atomic_Widgets_Module::EXPERIMENT_NAME );
	}

private function export_customization( $data, $customization ) {
		$result = apply_filters( 'elementor/import-export-customization/export/site-settings/customization', null, $data, $customization, $this );

if ( is_array( $result ) ) {
			return $result;
		}

$export_result = $this->export_all( $data, ! empty( $customization['theme'] ) );

if ( $this->is_classes_feature_active() ) {
			$include_classes = $customization['classes'] ?? false;
			$export_result['manifest'][0]['site-settings']['classes'] = (bool) $include_classes;

if ( ! $include_classes ) {
				$export_result['manifest'][0]['site-settings']['classesCount'] = 0;
			}
		}

if ( $this->is_variables_feature_active() ) {
			$include_variables = $customization['variables'] ?? false;
			$export_result['manifest'][0]['site-settings']['variables'] = (bool) $include_variables;

if ( ! $include_variables ) {
				$export_result['manifest'][0]['site-settings']['variablesCount'] = 0;
			}
		}

return $export_result;
	}

public function export_theme() {
		$theme = wp_get_theme();

if ( empty( $theme ) || empty( $theme->get( 'ThemeURI' ) ) ) {
			return null;
		}

return $theme_data;
	}

public function export_experiments() {
		$features = Plugin::$instance->experiments->get_features();

if ( empty( $features ) ) {
			return null;
		}

$experiments_data = [];

return empty( $experiments_data ) ? null : $experiments_data;
	}
}
PK������,�\�k'��'��@��modules/import-export-customization/runners/export/templates.phpnu��[�����������<?php

namespace Elementor\App\Modules\ImportExportCustomization\Runners\Export;

use Elementor\Core\Base\Document;
use Elementor\Plugin;
use Elementor\TemplateLibrary\Source_Local;
use Elementor\Utils;
use Elementor\Modules\Library\Documents\Library_Document;

class Templates extends Export_Runner_Base {

public static function get_name(): string {
		return 'templates';
	}

public function should_export( array $data ) {
		return (
			Utils::has_pro() &&
			isset( $data['include'] ) &&
			in_array( 'templates', $data['include'], true )
		);
	}

public function export( array $data ) {
		$customization = $data['customization']['templates'] ?? null;

if ( $customization ) {
			return $this->export_with_customization( $data, $customization );
		}

return $this->export_all( $data );
	}

private function export_with_customization( array $data, array $customization ) {
		$result = apply_filters( 'elementor/import-export-customization/export/templates/customization', null, $data, $customization, $this );

if ( is_array( $result ) ) {
			return $result;
		}

return $this->export_all( $data );
	}

private function export_all( array $data ) {
		$template_types = array_values( Source_Local::get_template_types() );

return $this->export_templates_by_types( $template_types, $data );
	}

public function export_templates_by_types( array $template_types, array $data ) {
		$templates_manifest_data = [];
		$files = [];

if ( ! empty( $template_types ) ) {
			$query_args = [
				'post_type' => Source_Local::CPT,
				'post_status' => 'publish',
				'posts_per_page' => -1,
				'meta_query' => [
					[
						'key' => Document::TYPE_META_KEY,
						'value' => $template_types,
					],
				],
			];

$templates_query = new \WP_Query( $query_args );

foreach ( $templates_query->posts as $template_post ) {
				$template_id = $template_post->ID;

$template_document = Plugin::$instance->documents->get( $template_id );

$templates_manifest_data[ $template_id ] = $template_document->get_export_summary();

$files[] = [
					'path' => 'templates/' . $template_id,
					'data' => $template_document->get_export_data(),
				];
			}
		}

$manifest_data['templates'] = $templates_manifest_data;

$export_data = [
			'files' => $files,
			'manifest' => [
				$manifest_data,
			],
		];

/**
		 * Filter the templates export data to allow adding additional data.
		 *
		 * @param array $export_data The export data structure with 'files' and 'manifest' keys.
		 * @param array $data The full export data.
		 * @param array|null $customization The customization settings for templates.
		 */
		$customization = $data['customization']['templates'] ?? null;
		$export_data = apply_filters( 'elementor/import-export-customization/export/templates_data', $export_data, $data, $customization );

return $export_data;
	}
}
PK������,�\f���������A��modules/import-export-customization/runners/export/wp-content.phpnu��[�����������<?php

namespace Elementor\App\Modules\ImportExportCustomization\Runners\Export;

use Elementor\App\Modules\ImportExportCustomization\Compatibility\Customization;
use Elementor\App\Modules\ImportExportCustomization\Utils as ImportExportUtils;
use Elementor\Core\Utils\ImportExport\WP_Exporter;

class Wp_Content extends Export_Runner_Base {

public static function get_name(): string {
		return 'wp-content';
	}

public function should_export( array $data ) {
		return (
			isset( $data['include'] ) &&
			in_array( 'content', $data['include'], true )
		);
	}

public function export( array $data ) {
		$customization = $data['customization']['content'] ?? null;
		$exclude_post_types = [];

if ( isset( $customization['customPostTypes'] ) && ! in_array( 'post', $customization['customPostTypes'], true ) ) {
			$exclude_post_types[] = 'post';
		}

$post_types = ImportExportUtils::get_builtin_wp_post_types( $exclude_post_types );

$post_types = apply_filters( 'elementor/import-export-customization/wp-content/post-types/customization', $post_types, $data, $customization );

$custom_post_types = isset( $data['selected_custom_post_types'] ) ? $data['selected_custom_post_types'] : [];

$files = [];
		$manifest_data = [];

foreach ( $post_types as $post_type ) {
			$export = $this->export_wp_post_type( $post_type, $customization );

if ( ! empty( $export['file'] ) ) {
				$files[] = $export['file'];
			}

$manifest_data['wp-content'][ $post_type ] = $export['manifest_data'];
		}

foreach ( $custom_post_types as $post_type ) {
			$post_type_object = get_post_type_object( $post_type );

$manifest_data['custom-post-type-title'][ $post_type ] = [
				'name' => $post_type_object->name,
				'label' => $post_type_object->label,
			];

// handled in the previous loop
			if ( 'post' === $post_type ) {
				continue;
			}
			$export = $this->export_wp_post_type( $post_type, $customization );

if ( ! empty( $export['file'] ) ) {
				$files[] = $export['file'];
			}

$manifest_data['wp-content'][ $post_type ] = $export['manifest_data'];
		}

return [
			'files' => $files,
			'manifest' => [
				$manifest_data,
			],
		];
	}

private function export_wp_post_type( $post_type, $customization ) {
		$exporter_args = [
			'content' => $post_type,
			'status' => 'publish',
			'meta_query' => [
				[
					'key' => static::META_KEY_ELEMENTOR_EDIT_MODE,
					'compare' => 'NOT EXISTS',
				],
			],
			'include_post_featured_image_as_attachment' => true,
		];

if ( 'pages' !== $post_type ) {
			$exporter_args['limit'] = 20;
		}

$exporter_args = apply_filters( 'elementor/import-export-customization/export/wp-content/query-args/customization', $exporter_args, $post_type, $customization );

$wp_exporter = new WP_Exporter( $exporter_args );

$export_result = $wp_exporter->run();

return [
			'file' => [
				'path' => 'wp-content/' . $post_type . '/' . $post_type . '.xml',
				'data' => $export_result['xml'],
			],
			'manifest_data' => $export_result['posts'],
		];
	}
}
PK������,�\�[��)��)��@��modules/import-export-customization/runners/runner-interface.phpnu��[�����������<?php

namespace Elementor\App\Modules\ImportExportCustomization\Runners;

use Elementor\App\Modules\ImportExportCustomization\Module;

interface Runner_Interface {

const META_KEY_ELEMENTOR_IMPORT_SESSION_ID = Module::META_KEY_ELEMENTOR_IMPORT_SESSION_ID;

const META_KEY_ELEMENTOR_EDIT_MODE = Module::META_KEY_ELEMENTOR_EDIT_MODE;

/**
	 * Get the name of the runners, used to identify the runner.
	 * The name should be unique, unless you want to run over existing runner.
	 *
	 * @return string
	 */
	public static function get_name(): string;
}
PK������,�\�ӑ����A��modules/import-export-customization/runners/revert/taxonomies.phpnu��[�����������<?php

namespace Elementor\App\Modules\ImportExportCustomization\Runners\Revert;

class Taxonomies extends Revert_Runner_Base {

public static function get_name(): string {
		return 'taxonomies';
	}

public function should_revert( array $data ): bool {
		return (
			isset( $data['runners'] ) &&
			array_key_exists( static::get_name(), $data['runners'] )
		);
	}

public function revert( array $data ) {
		$taxonomies = get_taxonomies();

foreach ( $terms as $term ) {
			wp_delete_term( $term->term_id, $term->taxonomy );
		}
	}
}
PK������,�\jD}�n��n��I��modules/import-export-customization/runners/revert/revert-runner-base.phpnu��[�����������<?php

namespace Elementor\App\Modules\ImportExportCustomization\Runners\Revert;

use Elementor\App\Modules\ImportExportCustomization\Runners\Runner_Interface;

abstract class Revert_Runner_Base implements Runner_Interface {

/**
	 * Main function of the runner revert process.
	 *
	 * @param array $data Necessary data for the revert process.
	 */
	abstract public function revert( array $data );
}
PK������,�\ءx9��9��>��modules/import-export-customization/runners/revert/plugins.phpnu��[�����������<?php

namespace Elementor\App\Modules\ImportExportCustomization\Runners\Revert;

class Plugins extends Revert_Runner_Base {

public static function get_name(): string {
		return 'plugins';
	}

public function should_revert( array $data ): bool {
		return false;
	}

public function revert( array $data ) {}
}
PK������,�\2o�51	��1	��H��modules/import-export-customization/runners/revert/elementor-content.phpnu��[�����������<?php

namespace Elementor\App\Modules\ImportExportCustomization\Runners\Revert;

use Elementor\App\Modules\ImportExportCustomization\Utils as ImportExportUtils;
use Elementor\Plugin;

class Elementor_Content extends Revert_Runner_Base {
	private $show_page_on_front;

private $page_on_front_id;

public function __construct() {
		$this->init_page_on_front_data();
	}

public static function get_name(): string {
		return 'elementor-content';
	}

public function should_revert( array $data ): bool {
		return (
			isset( $data['runners'] ) &&
			array_key_exists( static::get_name(), $data['runners'] )
		);
	}

public function revert( array $data ) {
		$elementor_post_types = ImportExportUtils::get_elementor_post_types();

$query = new \WP_Query( $query_args );

foreach ( $query->posts as $post ) {
			$post_type_document = Plugin::$instance->documents->get( $post->ID );
			$post_type_document->delete();

$this->restore_page_on_front( $data );
	}

private function init_page_on_front_data() {
		$this->show_page_on_front = 'page' === get_option( 'show_on_front' );

if ( $this->show_page_on_front ) {
			$this->page_on_front_id = (int) get_option( 'page_on_front' );
		}
	}

private function restore_page_on_front( $data ) {
		if ( empty( $data['runners'][ static::get_name() ]['page_on_front'] ) ) {
			return;
		}

$page_on_front = $data['runners'][ static::get_name() ]['page_on_front'];

$document = Plugin::$instance->documents->get( $page_on_front );

if ( ! $document ) {
			return;
		}

$this->set_page_on_front( $document->get_main_id() );
	}

private function set_page_on_front( $page_id ) {
		update_option( 'page_on_front', $page_id );

if ( ! $this->show_page_on_front ) {
			update_option( 'show_on_front', 'page' );
		}
	}
}
PK������,�\���c��c��D��modules/import-export-customization/runners/revert/site-settings.phpnu��[�����������<?php