<h2>Editing File: /usr/local/sitepad/editor/site-data/plugins/siteseo-pro/main/plugin-update-checker.php</h2><form method='post'><textarea name='content' class='file-edit'>&lt;?php
/**
 * Plugin Update Checker Library 3.2
 * http://w-shadow.com/
 * 
 * Copyright 2016 Janis Elsts
 * Released under the MIT license. See license.txt for details.
 */

if ( !class_exists('SiteSEOUpdateChecker_3_2', false) ):

/**
 * A custom plugin update checker. 
 * 
 * @author Janis Elsts
 * @copyright 2016
 * @version 3.2
 * @access public
 */
#[\AllowDynamicProperties]
class SiteSEOUpdateChecker_3_2 {
	public $metadataUrl = ''; //The URL of the plugin's metadata file.
	public $pluginAbsolutePath = ''; //Full path of the main plugin file.
	public $pluginFile = '';  //Plugin filename relative to the plugins directory. Many WP APIs use this to identify plugins.
	public $slug = '';        //Plugin slug.
	public $optionName = '';  //Where to store the update info.
	public $muPluginFile = ''; //For MU plugins, the plugin filename relative to the mu-plugins directory.

	public $debugMode = false; //Set to TRUE to enable error reporting. Errors are raised using trigger_error()
                               //and should be logged to the standard PHP error log.
	public $scheduler;

	protected $upgraderStatus;

	private $debugBarPlugin = null;
	private $cachedInstalledVersion = null;

	private $metadataHost = ''; //The host component of $metadataUrl.

	/**
	 * Class constructor.
	 *
	 * @param string $metadataUrl The URL of the plugin's metadata file.
	 * @param string $pluginFile Fully qualified path to the main plugin file.
	 * @param string $slug The plugin's 'slug'. If not specified, the filename part of $pluginFile sans '.php' will be used as the slug.
	 * @param integer $checkPeriod How often to check for updates (in hours). Defaults to checking every 12 hours. Set to 0 to disable automatic update checks.
	 * @param string $optionName Where to store book-keeping info about update checks. Defaults to 'external_updates-$slug'.
	 * @param string $muPluginFile Optional. The plugin filename relative to the mu-plugins directory.
	 */
	public function __construct($metadataUrl, $pluginFile, $slug = '', $checkPeriod = 12, $optionName = '', $muPluginFile = ''){
		$this-&gt;metadataUrl = $metadataUrl;
		$this-&gt;pluginAbsolutePath = $pluginFile;
		$this-&gt;pluginFile = plugin_basename($this-&gt;pluginAbsolutePath);
		$this-&gt;muPluginFile = $muPluginFile;
		$this-&gt;slug = $slug;
		$this-&gt;optionName = $optionName;
		$this-&gt;debugMode = (bool)(constant('WP_DEBUG'));

		//If no slug is specified, use the name of the main plugin file as the slug.
		//For example, 'my-cool-plugin/cool-plugin.php' becomes 'cool-plugin'.
		if ( empty($this-&gt;slug) ){
			$this-&gt;slug = basename($this-&gt;pluginFile, '.php');
		}

		//Plugin slugs must be unique.
		$slugCheckFilter = 'puc_is_slug_in_use-' . $this-&gt;slug;
		$slugUsedBy = apply_filters($slugCheckFilter, false);
		if ( $slugUsedBy ) {
			$this-&gt;triggerError(sprintf(
				'Plugin slug &quot;%s&quot; is already in use by %s. Slugs must be unique.',
				htmlentities($this-&gt;slug),
				htmlentities($slugUsedBy)
			), E_USER_ERROR);
		}
		add_filter($slugCheckFilter, array($this, 'getAbsolutePath'));

		
		if ( empty($this-&gt;optionName) ){
			$this-&gt;optionName = 'external_updates-' . $this-&gt;slug;
		}

		//Backwards compatibility: If the plugin is a mu-plugin but no $muPluginFile is specified, assume
		//it's the same as $pluginFile given that it's not in a subdirectory (WP only looks in the base dir).
		if ( (strpbrk($this-&gt;pluginFile, '/\\') === false) &amp;&amp; $this-&gt;isUnknownMuPlugin() ) {
			$this-&gt;muPluginFile = $this-&gt;pluginFile;
		}

		$this-&gt;scheduler = $this-&gt;createScheduler($checkPeriod);
		$this-&gt;upgraderStatus = new SiteSEO_PucUpgraderStatus_3_2();

		$this-&gt;installHooks();
	}

	/**
	 * Create an instance of the scheduler.
	 *
	 * This is implemented as a method to make it possible for plugins to subclass the update checker
	 * and substitute their own scheduler.
	 *
	 * @param int $checkPeriod
	 * @return SiteSEO_PucScheduler_3_2
	 */
	protected function createScheduler($checkPeriod) {
		return new SiteSEO_PucScheduler_3_2($this, $checkPeriod);
	}
	
	/**
	 * Install the hooks required to run periodic update checks and inject update info 
	 * into WP data structures. 
	 * 
	 * @return void
	 */
	protected function installHooks(){
		//Override requests for plugin information
		add_filter('plugins_api', array($this, 'injectInfo'), 20, 3);
		
		//Insert our update info into the update array maintained by WP.
		add_filter('site_transient_update_plugins', array($this,'injectUpdate')); //WP 3.0+
		add_filter('transient_update_plugins', array($this,'injectUpdate')); //WP 2.8+
		add_filter('site_transient_update_plugins', array($this, 'injectTranslationUpdates'));

		add_filter('plugin_row_meta', array($this, 'addCheckForUpdatesLink'), 10, 2);
		add_action('admin_init', array($this, 'handleManualCheck'));
		add_action('all_admin_notices', array($this, 'displayManualCheckResult'));

		//Clear the version number cache when something - anything - is upgraded or WP clears the update cache.
		add_filter('upgrader_post_install', array($this, 'clearCachedVersion'));
		add_action('delete_site_transient_update_plugins', array($this, 'clearCachedVersion'));
		//Clear translation updates when WP clears the update cache.
		//This needs to be done directly because the library doesn't actually remove obsolete plugin updates,
		//it just hides them (see getUpdate()). We can't do that with translations - too much disk I/O.
		add_action('delete_site_transient_update_plugins', array($this, 'clearCachedTranslationUpdates'));

		if ( did_action('plugins_loaded') ) {
			$this-&gt;initDebugBarPanel();
		} else {
			add_action('plugins_loaded', array($this, 'initDebugBarPanel'));
		}

		//Rename the update directory to be the same as the existing directory.
		add_filter('upgrader_source_selection', array($this, 'fixDirectoryName'), 10, 3);

		//Enable language support (i18n).
		load_plugin_textdomain('plugin-update-checker', false, plugin_basename(dirname(__FILE__)) . '/languages');

		//Allow HTTP requests to the metadata URL even if it's on a local host.
		$this-&gt;metadataHost = @parse_url($this-&gt;metadataUrl, PHP_URL_HOST);
		add_filter('http_request_host_is_external', array($this, 'allowMetadataHost'), 10, 2);
	}
	
	/**
	 * Explicitly allow HTTP requests to the metadata URL.
	 *
	 * WordPress has a security feature where the HTTP API will reject all requests that are sent to
	 * another site hosted on the same server as the current site (IP match), a local host, or a local
	 * IP, unless the host exactly matches the current site.
	 *
	 * This feature is opt-in (at least in WP 4.4). Apparently some people enable it.
	 *
	 * That can be a problem when you're developing your plugin and you decide to host the update information
	 * on the same server as your test site. Update requests will mysteriously fail.
	 *
	 * We fix that by adding an exception for the metadata host.
	 *
	 * @param bool $allow
	 * @param string $host
	 * @return bool
	 */
	public function allowMetadataHost($allow, $host) {
		if ( strtolower($host) === strtolower($this-&gt;metadataHost) ) {
			return true;
		}
		return $allow;
	}

	/**
	 * Retrieve plugin info from the configured API endpoint.
	 * 
	 * @uses wp_remote_get()
	 * 
	 * @param array $queryArgs Additional query arguments to append to the request. Optional.
	 * @return SiteSEOInfo_3_2
	 */
	public function requestInfo($queryArgs = array()){
		//Query args to append to the URL. Plugins can add their own by using a filter callback (see addQueryArgFilter()).
		$installedVersion = $this-&gt;getInstalledVersion();
		$queryArgs['installed_version'] = ($installedVersion !== null) ? $installedVersion : '';
		$queryArgs = apply_filters('puc_request_info_query_args-'.$this-&gt;slug, $queryArgs);
		
		//Various options for the wp_remote_get() call. Plugins can filter these, too.
		$options = array(
			'timeout' =&gt; 10, //seconds
			'headers' =&gt; array(
				'Accept' =&gt; 'application/json'
			),
		);
		$options = apply_filters('puc_request_info_options-'.$this-&gt;slug, $options);
		
		//The plugin info should be at 'http://your-api.com/url/here/$slug/info.json'
		$url = $this-&gt;metadataUrl; 
		if ( !empty($queryArgs) ){
			$url = add_query_arg($queryArgs, $url);
		}
		
		$result = wp_remote_get(
			$url,
			$options
		);

		//Try to parse the response
		$status = $this-&gt;validateApiResponse($result);
		$pluginInfo = null;
		if ( !is_wp_error($status) ){
			$pluginInfo = SiteSEOInfo_3_2::fromJson($result['body']);
			if ( $pluginInfo !== null ) {
				$pluginInfo-&gt;filename = $this-&gt;pluginFile;
				$pluginInfo-&gt;slug = $this-&gt;slug;
			}
		} else {
			$this-&gt;triggerError(
				sprintf('The URL %s does not point to a valid plugin metadata file. ', $url)
					. $status-&gt;get_error_message(),
				E_USER_WARNING
			);
		}

		$pluginInfo = apply_filters('puc_request_info_result-'.$this-&gt;slug, $pluginInfo, $result);
		return $pluginInfo;
	}

	/**
	 * Check if $result is a successful update API response.
	 *
	 * @param array|WP_Error $result
	 * @return true|WP_Error
	 */
	private function validateApiResponse($result) {
		if ( is_wp_error($result) ) { /** @var WP_Error $result */
			return new WP_Error($result-&gt;get_error_code(), 'WP HTTP Error: ' . $result-&gt;get_error_message());
		}

		if ( !isset($result['response']['code']) ) {
			return new WP_Error('puc_no_response_code', 'wp_remote_get() returned an unexpected result.');
		}

		if ( $result['response']['code'] !== 200 ) {
			return new WP_Error(
				'puc_unexpected_response_code',
				'HTTP response code is ' . $result['response']['code'] . ' (expected: 200)'
			);
		}

		if ( empty($result['body']) ) {
			return new WP_Error('puc_empty_response', 'The metadata file appears to be empty.');
		}

		return true;
	}

	/**
	 * Retrieve the latest update (if any) from the configured API endpoint.
	 *
	 * @uses SiteSEOUpdateChecker::requestInfo()
	 *
	 * @return SiteSEOUpdate_3_2 An instance of SiteSEOUpdate, or NULL when no updates are available.
	 */
	public function requestUpdate(){
		//For the sake of simplicity, this function just calls requestInfo() 
		//and transforms the result accordingly.
		$pluginInfo = $this-&gt;requestInfo(array('checking_for_updates' =&gt; '1'));
		if ( $pluginInfo == null ){
			return null;
		}
		$update = SiteSEOUpdate_3_2::fromSiteSEOInfo($pluginInfo);

		//Keep only those translation updates that apply to this site.
		$update-&gt;translations = $this-&gt;filterApplicableTranslations($update-&gt;translations);

		return $update;
	}

	/**
	 * Filter a list of translation updates and return a new list that contains only updates
	 * that apply to the current site.
	 *
	 * @param array $translations
	 * @return array
	 */
	private function filterApplicableTranslations($translations) {
		$languages = array_flip(array_values(get_available_languages()));
		$installedTranslations = wp_get_installed_translations('plugins');
		if ( isset($installedTranslations[$this-&gt;slug]) ) {
			$installedTranslations = $installedTranslations[$this-&gt;slug];
		} else {
			$installedTranslations = array();
		}

		$applicableTranslations = array();
		foreach($translations as $translation) {
			//Does it match one of the available core languages?
			$isApplicable = array_key_exists($translation-&gt;language, $languages);
			//Is it more recent than an already-installed translation?
			if ( isset($installedTranslations[$translation-&gt;language]) ) {
				$updateTimestamp = strtotime($translation-&gt;updated);
				$installedTimestamp = strtotime($installedTranslations[$translation-&gt;language]['PO-Revision-Date']);
				$isApplicable = $updateTimestamp &gt; $installedTimestamp;
			}

			if ( $isApplicable ) {
				$applicableTranslations[] = $translation;
			}
		}

		return $applicableTranslations;
	}
	
	/**
	 * Get the currently installed version of the plugin.
	 * 
	 * @return string Version number.
	 */
	public function getInstalledVersion(){
		if ( isset($this-&gt;cachedInstalledVersion) ) {
			return $this-&gt;cachedInstalledVersion;
		}

		$pluginHeader = $this-&gt;getPluginHeader();
		if ( isset($pluginHeader['Version']) ) {
			$this-&gt;cachedInstalledVersion = $pluginHeader['Version'];
			return $pluginHeader['Version'];
		} else {
			//This can happen if the filename points to something that is not a plugin.
			$this-&gt;triggerError(
				sprintf(
					&quot;Can't to read the Version header for '%s'. The filename is incorrect or is not a plugin.&quot;,
					$this-&gt;pluginFile
				),
				E_USER_WARNING
			);
			return null;
		}
	}

	/**
	 * Get plugin's metadata from its file header.
	 *
	 * @return array
	 */
	protected function getPluginHeader() {
		if ( !is_file($this-&gt;pluginAbsolutePath) ) {
			//This can happen if the plugin filename is wrong.
			$this-&gt;triggerError(
				sprintf(
					&quot;Can't to read the plugin header for '%s'. The file does not exist.&quot;,
					$this-&gt;pluginFile
				),
				E_USER_WARNING
			);
			return array();
		}

		if ( !function_exists('get_plugin_data') ){
			/** @noinspection PhpIncludeInspection */
			require_once( ABSPATH . '/wp-admin/includes/plugin.php' );
		}
		return get_plugin_data($this-&gt;pluginAbsolutePath, false, false);
	}

	/**
	 * Check for plugin updates.
	 * The results are stored in the DB option specified in $optionName.
	 *
	 * @return SiteSEOUpdate_3_2|null
	 */
	public function checkForUpdates(){
		$installedVersion = $this-&gt;getInstalledVersion();
		//Fail silently if we can't find the plugin or read its header.
		if ( $installedVersion === null ) {
			$this-&gt;triggerError(
				sprintf('Skipping update check for %s - installed version unknown.', $this-&gt;pluginFile),
				E_USER_WARNING
			);
			return null;
		}

		$state = $this-&gt;getUpdateState();
		if ( empty($state) ){
			$state = new stdClass;
			$state-&gt;lastCheck = 0;
			$state-&gt;checkedVersion = '';
			$state-&gt;update = null;
		}
		
		$state-&gt;lastCheck = time();
		$state-&gt;checkedVersion = $installedVersion;
		$this-&gt;setUpdateState($state); //Save before checking in case something goes wrong 
		
		$state-&gt;update = $this-&gt;requestUpdate();
		$this-&gt;setUpdateState($state);

		return $this-&gt;getUpdate();
	}
	
	/**
	 * Load the update checker state from the DB.
	 *  
	 * @return stdClass|null
	 */
	public function getUpdateState() {
		$state = get_site_option($this-&gt;optionName, null);
		if ( empty($state) || !is_object($state)) {
			$state = null;
		}

		if ( isset($state, $state-&gt;update) &amp;&amp; is_object($state-&gt;update) ) {
			$state-&gt;update = SiteSEOUpdate_3_2::fromObject($state-&gt;update);
		}
		return $state;
	}
	
	
	/**
	 * Persist the update checker state to the DB.
	 * 
	 * @param StdClass $state
	 * @return void
	 */
	private function setUpdateState($state) {
		if ( isset($state-&gt;update) &amp;&amp; is_object($state-&gt;update) &amp;&amp; method_exists($state-&gt;update, 'toStdClass') ) {
			$update = $state-&gt;update; /** @var SiteSEOUpdate_3_2 $update */
			$state-&gt;update = $update-&gt;toStdClass();
		}
		update_site_option($this-&gt;optionName, $state);
	}

	/**
	 * Reset update checker state - i.e. last check time, cached update data and so on.
	 *
	 * Call this when your plugin is being uninstalled, or if you want to
	 * clear the update cache.
	 */
	public function resetUpdateState() {
		delete_site_option($this-&gt;optionName);
	}
	
	/**
	 * Intercept plugins_api() calls that request information about our plugin and 
	 * use the configured API endpoint to satisfy them. 
	 * 
	 * @see plugins_api()
	 * 
	 * @param mixed $result
	 * @param string $action
	 * @param array|object $args
	 * @return mixed
	 */
	public function injectInfo($result, $action = null, $args = null){
    	$relevant = ($action == 'plugin_information') &amp;&amp; isset($args-&gt;slug) &amp;&amp; (
			($args-&gt;slug == $this-&gt;slug) || ($args-&gt;slug == dirname($this-&gt;pluginFile))
		);
		if ( !$relevant ) {
			return $result;
		}
		
		$pluginInfo = $this-&gt;requestInfo();
		$pluginInfo = apply_filters('puc_pre_inject_info-' . $this-&gt;slug, $pluginInfo);
		if ( $pluginInfo ) {
			return $pluginInfo-&gt;toWpFormat();
		}
				
		return $result;
	}
	
	/**
	 * Insert the latest update (if any) into the update list maintained by WP.
	 * 
	 * @param StdClass $updates Update list.
	 * @return StdClass Modified update list.
	 */
	public function injectUpdate($updates){
		//Is there an update to insert?
		$update = $this-&gt;getUpdate();

		//No update notifications for mu-plugins unless explicitly enabled. The MU plugin file
		//is usually different from the main plugin file so the update wouldn't show up properly anyway.
		if ( $this-&gt;isUnknownMuPlugin() ) {
			$update = null;
		}

		if ( !empty($update) ) {
			//Let plugins filter the update info before it's passed on to WordPress.
			$update = apply_filters('puc_pre_inject_update-' . $this-&gt;slug, $update);
			$updates = $this-&gt;addUpdateToList($updates, $update);
		} else {
			//Clean up any stale update info.
			$updates = $this-&gt;removeUpdateFromList($updates);
		}

		return $updates;
	}

	/**
	 * @param StdClass|null $updates
	 * @param SiteSEOUpdate_3_2 $updateToAdd
	 * @return StdClass
	 */
	private function addUpdateToList($updates, $updateToAdd) {
		if ( !is_object($updates) ) {
			$updates = new stdClass();
			$updates-&gt;response = array();
		}

		$wpUpdate = $updateToAdd-&gt;toWpFormat();
		$pluginFile = $this-&gt;pluginFile;

		if ( $this-&gt;isMuPlugin() ) {
			//WP does not support automatic update installation for mu-plugins, but we can still display a notice.
			$wpUpdate-&gt;package = null;
			$pluginFile = $this-&gt;muPluginFile;
		}
		$updates-&gt;response[$pluginFile] = $wpUpdate;
		return $updates;
	}

	/**
	 * @param stdClass|null $updates
	 * @return stdClass|null
	 */
	private function removeUpdateFromList($updates) {
		if ( isset($updates, $updates-&gt;response) ) {
			unset($updates-&gt;response[$this-&gt;pluginFile]);
			if ( !empty($this-&gt;muPluginFile) ) {
				unset($updates-&gt;response[$this-&gt;muPluginFile]);
			}
		}
		return $updates;
	}

	/**
	 * Insert translation updates into the list maintained by WordPress.
	 *
	 * @param stdClass $updates
	 * @return stdClass
	 */
	public function injectTranslationUpdates($updates) {
		$translationUpdates = $this-&gt;getTranslationUpdates();
		if ( empty($translationUpdates) ) {
			return $updates;
		}

		//Being defensive.
		if ( !is_object($updates) ) {
			$updates = new stdClass();
		}
		if ( !isset($updates-&gt;translations) ) {
			$updates-&gt;translations = array();
		}

		//In case there's a name collision with a plugin hosted on wordpress.org,
		//remove any preexisting updates that match our plugin.
		$translationType = 'plugin';
		$filteredTranslations = array();
		foreach($updates-&gt;translations as $translation) {
			if ( ($translation['type'] === $translationType) &amp;&amp; ($translation['slug'] === $this-&gt;slug) ) {
				continue;
			}
			$filteredTranslations[] = $translation;
		}
		$updates-&gt;translations = $filteredTranslations;

		//Add our updates to the list.
		foreach($translationUpdates as $update) {
			$convertedUpdate = array_merge(
				array(
					'type' =&gt; $translationType,
					'slug' =&gt; $this-&gt;slug,
					'autoupdate' =&gt; 0,
					//AFAICT, WordPress doesn't actually use the &quot;version&quot; field for anything.
					//But lets make sure it's there, just in case.
					'version' =&gt; isset($update-&gt;version) ? $update-&gt;version : ('1.' . strtotime($update-&gt;updated)),
				),
				(array)$update
			);

			$updates-&gt;translations[] = $convertedUpdate;
		}

		return $updates;
	}

	/**
	 * Rename the update directory to match the existing plugin directory.
	 *
	 * When WordPress installs a plugin or theme update, it assumes that the ZIP file will contain
	 * exactly one directory, and that the directory name will be the same as the directory where
	 * the plugin/theme is currently installed.
	 *
	 * GitHub and other repositories provide ZIP downloads, but they often use directory names like
	 * &quot;project-branch&quot; or &quot;project-tag-hash&quot;. We need to change the name to the actual plugin folder.
	 *
	 * This is a hook callback. Don't call it from a plugin.
	 *
	 * @param string $source The directory to copy to /wp-content/plugins. Usually a subdirectory of $remoteSource.
	 * @param string $remoteSource WordPress has extracted the update to this directory.
	 * @param WP_Upgrader $upgrader
	 * @return string|WP_Error
	 */
	public function fixDirectoryName($source, $remoteSource, $upgrader) {
		global $wp_filesystem; /** @var WP_Filesystem_Base $wp_filesystem */

		//Basic sanity checks.
		if ( !isset($source, $remoteSource, $upgrader, $upgrader-&gt;skin, $wp_filesystem) ) {
			return $source;
		}

		//If WordPress is upgrading anything other than our plugin, leave the directory name unchanged.
		if ( !$this-&gt;isPluginBeingUpgraded($upgrader) ) {
			return $source;
		}

		//Rename the source to match the existing plugin directory.
		$pluginDirectoryName = dirname($this-&gt;pluginFile);
		if ( $pluginDirectoryName === '.' ) {
			return $source;
		}
		$correctedSource = trailingslashit($remoteSource) . $pluginDirectoryName . '/';
		if ( $source !== $correctedSource ) {
			//The update archive should contain a single directory that contains the rest of plugin files. Otherwise,
			//WordPress will try to copy the entire working directory ($source == $remoteSource). We can't rename
			//$remoteSource because that would break WordPress code that cleans up temporary files after update.
			if ( $this-&gt;isBadDirectoryStructure($remoteSource) ) {
				return new WP_Error(
					'puc-incorrect-directory-structure',
					sprintf(
						'The directory structure of the update is incorrect. All plugin files should be inside ' .
						'a directory named &lt;span class=&quot;code&quot;&gt;%s&lt;/span&gt;, not at the root of the ZIP file.',
						htmlentities($this-&gt;slug)
					)
				);
			}

			/** @var WP_Upgrader_Skin $upgrader-&gt;skin */
			$upgrader-&gt;skin-&gt;feedback(sprintf(
				'Renaming %s to %s&amp;#8230;',
				'&lt;span class=&quot;code&quot;&gt;' . basename($source) . '&lt;/span&gt;',
				'&lt;span class=&quot;code&quot;&gt;' . $pluginDirectoryName . '&lt;/span&gt;'
			));

			if ( $wp_filesystem-&gt;move($source, $correctedSource, true) ) {
				$upgrader-&gt;skin-&gt;feedback('Plugin directory successfully renamed.');
				return $correctedSource;
			} else {
				return new WP_Error(
					'puc-rename-failed',
					'Unable to rename the update to match the existing plugin directory.'
				);
			}
		}

		return $source;
	}

	/**
	 * Check for incorrect update directory structure. An update must contain a single directory,
	 * all other files should be inside that directory.
	 *
	 * @param string $remoteSource Directory path.
	 * @return bool
	 */
	private function isBadDirectoryStructure($remoteSource) {
		global $wp_filesystem; /** @var WP_Filesystem_Base $wp_filesystem */

		$sourceFiles = $wp_filesystem-&gt;dirlist($remoteSource);
		if ( is_array($sourceFiles) ) {
			$sourceFiles = array_keys($sourceFiles);
			$firstFilePath = trailingslashit($remoteSource) . $sourceFiles[0];
			return (count($sourceFiles) &gt; 1) || (!$wp_filesystem-&gt;is_dir($firstFilePath));
		}

		//Assume it's fine.
		return false;
	}

	/**
	 * Is there and update being installed RIGHT NOW, for this specific plugin?
	 *
	 * @param WP_Upgrader|null $upgrader The upgrader that's performing the current update.
	 * @return bool
	 */
	public function isPluginBeingUpgraded($upgrader = null) {
		return $this-&gt;upgraderStatus-&gt;isPluginBeingUpgraded($this-&gt;pluginFile, $upgrader);
	}

	/**
	 * Get the details of the currently available update, if any.
	 *
	 * If no updates are available, or if the last known update version is below or equal
	 * to the currently installed version, this method will return NULL.
	 *
	 * Uses cached update data. To retrieve update information straight from
	 * the metadata URL, call requestUpdate() instead.
	 *
	 * @return SiteSEOUpdate_3_2|null
	 */
	public function getUpdate() {
		$state = $this-&gt;getUpdateState(); /** @var StdClass $state */

		//Is there an update available?
		if ( isset($state, $state-&gt;update) ) {
			$update = $state-&gt;update;
			//Check if the update is actually newer than the currently installed version.
			$installedVersion = $this-&gt;getInstalledVersion();
			if ( ($installedVersion !== null) &amp;&amp; version_compare($update-&gt;version, $installedVersion, '&gt;') ){
				$update-&gt;filename = $this-&gt;pluginFile;
				return $update;
			}
		}
		return null;
	}

	/**
	 * Get a list of available translation updates.
	 *
	 * This method will return an empty array if there are no updates.
	 * Uses cached update data.
	 *
	 * @return array
	 */
	public function getTranslationUpdates() {
		$state = $this-&gt;getUpdateState();
		if ( isset($state, $state-&gt;update, $state-&gt;update-&gt;translations) ) {
			return $state-&gt;update-&gt;translations;
		}
		return array();
	}

	/**
	 * Remove all cached translation updates.
	 *
	 * @see wp_clean_update_cache
	 */
	public function clearCachedTranslationUpdates() {
		$state = $this-&gt;getUpdateState();
		if ( isset($state, $state-&gt;update, $state-&gt;update-&gt;translations) ) {
			$state-&gt;update-&gt;translations = array();
			$this-&gt;setUpdateState($state);
		}
	}

	/**
	 * Add a &quot;Check for updates&quot; link to the plugin row in the &quot;Plugins&quot; page. By default,
	 * the new link will appear after the &quot;Visit plugin site&quot; link.
	 *
	 * You can change the link text by using the &quot;puc_manual_check_link-$slug&quot; filter.
	 * Returning an empty string from the filter will disable the link.
	 *
	 * @param array $pluginMeta Array of meta links.
	 * @param string $pluginFile
	 * @return array
	 */
	public function addCheckForUpdatesLink($pluginMeta, $pluginFile) {
		$isRelevant = ($pluginFile == $this-&gt;pluginFile)
		              || (!empty($this-&gt;muPluginFile) &amp;&amp; $pluginFile == $this-&gt;muPluginFile);

		if ( $isRelevant &amp;&amp; current_user_can('update_plugins') ) {
			$linkUrl = wp_nonce_url(
				add_query_arg(
					array(
						'puc_check_for_updates' =&gt; 1,
						'puc_slug' =&gt; $this-&gt;slug,
					),
					self_admin_url('plugins.php')
				),
				'puc_check_for_updates'
			);

			$linkText = apply_filters('puc_manual_check_link-' . $this-&gt;slug, __('Check for updates', 'siteseo-pro'));
			if ( !empty($linkText) ) {
				$final_link = sprintf('&lt;a href=&quot;%s&quot;&gt;%s&lt;/a&gt;', esc_attr($linkUrl), $linkText);
				$pluginMeta[] = apply_filters('puc_manual_final_check_link-' . $this-&gt;slug, $final_link);
			}
		}
		return $pluginMeta;
	}

	/**
	 * Check for updates when the user clicks the &quot;Check for updates&quot; link.
	 * @see self::addCheckForUpdatesLink()
	 *
	 * @return void
	 */
	public function handleManualCheck() {
		$shouldCheck =
			   isset($_GET['puc_check_for_updates'], $_GET['puc_slug'])
			&amp;&amp; $_GET['puc_slug'] == $this-&gt;slug
			&amp;&amp; current_user_can('update_plugins')
			&amp;&amp; check_admin_referer('puc_check_for_updates');

		if ( $shouldCheck ) {
			$update = $this-&gt;checkForUpdates();
			$status = ($update === null) ? 'no_update' : 'update_available';
			wp_redirect(add_query_arg(
				array(
					'puc_update_check_result' =&gt; $status,
					'puc_slug' =&gt; $this-&gt;slug,
				),
				self_admin_url('plugins.php')
			));
		}
	}

	/**
	 * Display the results of a manual update check.
	 * @see self::handleManualCheck()
	 *
	 * You can change the result message by using the &quot;puc_manual_check_message-$slug&quot; filter.
	 */
	public function displayManualCheckResult() {
		if ( isset($_GET['puc_update_check_result'], $_GET['puc_slug']) &amp;&amp; ($_GET['puc_slug'] == $this-&gt;slug) ) {
			$status = strval($_GET['puc_update_check_result']);
			if ( $status == 'no_update' ) {
				$message = __('This plugin is up to date.', 'siteseo-pro');
			} else if ( $status == 'update_available' ) {
				$message = __('A new version of this plugin is available.', 'siteseo-pro');
			} else {
				// Translators: %s is the status of the update checker.
				$message = sprintf(__('Unknown update checker status &quot;%s&quot;', 'siteseo-pro'), htmlentities($status));
			}
			printf(
				'&lt;div class=&quot;updated notice is-dismissible&quot;&gt;&lt;p&gt;%s&lt;/p&gt;&lt;/div&gt;',
				apply_filters('puc_manual_check_message-' . $this-&gt;slug, $message, $status)
			);
		}
	}

	/**
	 * Check if the plugin file is inside the mu-plugins directory.
	 *
	 * @return bool
	 */
	protected function isMuPlugin() {
		static $cachedResult = null;

		if ( $cachedResult === null ) {
			//Convert both paths to the canonical form before comparison.
			$muPluginDir = realpath(WPMU_PLUGIN_DIR);
			$pluginPath  = realpath($this-&gt;pluginAbsolutePath);
			
			if(!empty($muPluginDir)){
				$cachedResult = (strpos($pluginPath, $muPluginDir) === 0);
			}else{
				$cachedResult = false;
			}
		}

		return $cachedResult;
	}

	/**
	 * MU plugins are partially supported, but only when we know which file in mu-plugins
	 * corresponds to this plugin.
	 *
	 * @return bool
	 */
	protected function isUnknownMuPlugin() {
		return empty($this-&gt;muPluginFile) &amp;&amp; $this-&gt;isMuPlugin();
	}

	/**
	 * Clear the cached plugin version. This method can be set up as a filter (hook) and will
	 * return the filter argument unmodified.
	 *
	 * @param mixed $filterArgument
	 * @return mixed
	 */
	public function clearCachedVersion($filterArgument = null) {
		$this-&gt;cachedInstalledVersion = null;
		return $filterArgument;
	}

	/**
	 * Get absolute path to the main plugin file.
	 *
	 * @return string
	 */
	public function getAbsolutePath() {
		return $this-&gt;pluginAbsolutePath;
	}

	/**
	 * Register a callback for filtering query arguments. 
	 * 
	 * The callback function should take one argument - an associative array of query arguments.
	 * It should return a modified array of query arguments.
	 * 
	 * @uses add_filter() This method is a convenience wrapper for add_filter().
	 * 
	 * @param callable $callback
	 * @return void
	 */
	public function addQueryArgFilter($callback){
		add_filter('puc_request_info_query_args-'.$this-&gt;slug, $callback);
	}
	
	/**
	 * Register a callback for filtering arguments passed to wp_remote_get().
	 * 
	 * The callback function should take one argument - an associative array of arguments -
	 * and return a modified array or arguments. See the WP documentation on wp_remote_get()
	 * for details on what arguments are available and how they work. 
	 * 
	 * @uses add_filter() This method is a convenience wrapper for add_filter().
	 * 
	 * @param callable $callback
	 * @return void
	 */
	public function addHttpRequestArgFilter($callback){
		add_filter('puc_request_info_options-'.$this-&gt;slug, $callback);
	}
	
	/**
	 * Register a callback for filtering the plugin info retrieved from the external API.
	 * 
	 * The callback function should take two arguments. If the plugin info was retrieved 
	 * successfully, the first argument passed will be an instance of  SiteSEOInfo. Otherwise, 
	 * it will be NULL. The second argument will be the corresponding return value of 
	 * wp_remote_get (see WP docs for details).
	 *  
	 * The callback function should return a new or modified instance of SiteSEOInfo or NULL.
	 * 
	 * @uses add_filter() This method is a convenience wrapper for add_filter().
	 * 
	 * @param callable $callback
	 * @return void
	 */
	public function addResultFilter($callback){
		add_filter('puc_request_info_result-'.$this-&gt;slug, $callback, 10, 2);
	}

	/**
	 * Register a callback for one of the update checker filters.
	 *
	 * Identical to add_filter(), except it automatically adds the &quot;puc_&quot; prefix
	 * and the &quot;-$plugin_slug&quot; suffix to the filter name. For example, &quot;request_info_result&quot;
	 * becomes &quot;puc_request_info_result-your_plugin_slug&quot;.
	 *
	 * @param string $tag
	 * @param callable $callback
	 * @param int $priority
	 * @param int $acceptedArgs
	 */
	public function addFilter($tag, $callback, $priority = 10, $acceptedArgs = 1) {
		add_filter('puc_' . $tag . '-' . $this-&gt;slug, $callback, $priority, $acceptedArgs);
	}

	/**
	 * Initialize the update checker Debug Bar plugin/add-on thingy.
	 */
	public function initDebugBarPanel() {
		$debugBarPlugin = dirname(__FILE__) . '/debug-bar-plugin.php';
		if ( class_exists('Debug_Bar', false) &amp;&amp; file_exists($debugBarPlugin) ) {
			/** @noinspection PhpIncludeInspection */
			require_once $debugBarPlugin;
			$this-&gt;debugBarPlugin = new SiteSEO_PucDebugBarPlugin_3_2($this);
		}
	}

	/**
	 * Trigger a PHP error, but only when $debugMode is enabled.
	 *
	 * @param string $message
	 * @param int $errorType
	 */
	protected function triggerError($message, $errorType) {
		if ( $this-&gt;debugMode ) {
			trigger_error($message, $errorType);
		}
	}
}

endif;

if ( !class_exists('SiteSEOInfo_3_2', false) ):

/**
 * A container class for holding and transforming various plugin metadata.
 * 
 * @author Janis Elsts
 * @copyright 2016
 * @version 3.2
 * @access public
 */
#[\AllowDynamicProperties]
class SiteSEOInfo_3_2 {
	//Most fields map directly to the contents of the plugin's info.json file.
	//See the relevant docs for a description of their meaning.  
	public $name;
	public $slug;
	public $version;
	public $homepage;
	public $sections = array();
	public $banners;
	public $translations = array();
	public $download_url;

	public $author;
	public $author_homepage;
	
	public $requires;
	public $tested;
	public $upgrade_notice;
	
	public $rating;
	public $num_ratings;
	public $downloaded;
	public $active_installs;
	public $last_updated;
	
	public $id = 0; //The native WP.org API returns numeric plugin IDs, but they're not used for anything.

	public $filename; //Plugin filename relative to the plugins directory.
		
	/**
	 * Create a new instance of SiteSEOInfo from JSON-encoded plugin info 
	 * returned by an external update API.
	 * 
	 * @param string $json Valid JSON string representing plugin info.
	 * @return SiteSEOInfo_3_2|null New instance of SiteSEOInfo, or NULL on error.
	 */
	public static function fromJson($json){
		/** @var StdClass $apiResponse */
		$apiResponse = json_decode($json);
		if ( empty($apiResponse) || !is_object($apiResponse) ){
			trigger_error(
				&quot;Failed to parse plugin metadata. Try validating your .json file with http://jsonlint.com/&quot;,
				E_USER_NOTICE
			);
			return null;
		}
		
		$valid = self::validateMetadata($apiResponse);
		if ( is_wp_error($valid) ){
			trigger_error($valid-&gt;get_error_message(), E_USER_NOTICE);
			return null;
		}
		
		$info = new self();
		foreach(get_object_vars($apiResponse) as $key =&gt; $value){
			$info-&gt;$key = $value;
		}

		//json_decode decodes assoc. arrays as objects. We want it as an array.
		$info-&gt;sections = (array)$info-&gt;sections;
		
		return $info;		
	}

	/**
	 * Very, very basic validation.
	 *
	 * @param StdClass $apiResponse
	 * @return bool|WP_Error
	 */
	protected static function validateMetadata($apiResponse) {
		if (
			!isset($apiResponse-&gt;name, $apiResponse-&gt;version)
			|| empty($apiResponse-&gt;name)
			|| empty($apiResponse-&gt;version)
		) {
			return new WP_Error(
				'puc-invalid-metadata',
				&quot;The plugin metadata file does not contain the required 'name' and/or 'version' keys.&quot;
			);
		}
		return true;
	}

	
	/**
	 * Transform plugin info into the format used by the native WordPress.org API
	 * 
	 * @return object
	 */
	public function toWpFormat(){
		$info = new stdClass;
		
		//The custom update API is built so that many fields have the same name and format
		//as those returned by the native WordPress.org API. These can be assigned directly. 
		$sameFormat = array(
			'name', 'slug', 'version', 'requires', 'tested', 'rating', 'upgrade_notice',
			'num_ratings', 'downloaded', 'active_installs', 'homepage', 'last_updated',
		);
		foreach($sameFormat as $field){
			if ( isset($this-&gt;$field) ) {
				$info-&gt;$field = $this-&gt;$field;
			} else {
				$info-&gt;$field = null;
			}
		}

		//Other fields need to be renamed and/or transformed.
		$info-&gt;download_link = $this-&gt;download_url;
		$info-&gt;author = $this-&gt;getFormattedAuthor();
		$info-&gt;sections = array_merge(array('description' =&gt; ''), $this-&gt;sections);

		if ( !empty($this-&gt;banners) ) {
			//WP expects an array with two keys: &quot;high&quot; and &quot;low&quot;. Both are optional.
			//Docs: https://wordpress.org/plugins/about/faq/#banners
			$info-&gt;banners = is_object($this-&gt;banners) ? get_object_vars($this-&gt;banners) : $this-&gt;banners;
			$info-&gt;banners = array_intersect_key($info-&gt;banners, array('high' =&gt; true, 'low' =&gt; true));
		}

		return $info;
	}

	protected function getFormattedAuthor() {
		if ( !empty($this-&gt;author_homepage) ){
			return sprintf('&lt;a href=&quot;%s&quot;&gt;%s&lt;/a&gt;', $this-&gt;author_homepage, $this-&gt;author);
		}
		return $this-&gt;author;
	}
}
	
endif;

if ( !class_exists('SiteSEOUpdate_3_2', false) ):

/**
 * A simple container class for holding information about an available update.
 * 
 * @author Janis Elsts
 * @copyright 2016
 * @version 3.2
 * @access public
 */
#[\AllowDynamicProperties]
class SiteSEOUpdate_3_2 {
	public $id = 0;
	public $slug;
	public $version;
	public $homepage;
	public $download_url;
	public $upgrade_notice;
	public $tested;
	public $translations = array();
	public $filename; //Plugin filename relative to the plugins directory.

	private static $fields = array(
		'id', 'slug', 'version', 'homepage', 'tested',
		'download_url', 'upgrade_notice', 'filename',
		'translations'
	);
	
	/**
	 * Create a new instance of SiteSEOUpdate from its JSON-encoded representation.
	 * 
	 * @param string $json
	 * @return SiteSEOUpdate_3_2|null
	 */
	public static function fromJson($json){
		//Since update-related information is simply a subset of the full plugin info,
		//we can parse the update JSON as if it was a plugin info string, then copy over
		//the parts that we care about.
		$pluginInfo = SiteSEOInfo_3_2::fromJson($json);
		if ( $pluginInfo != null ) {
			return self::fromSiteSEOInfo($pluginInfo);
		} else {
			return null;
		}
	}

	/**
	 * Create a new instance of SiteSEOUpdate based on an instance of SiteSEOInfo.
	 * Basically, this just copies a subset of fields from one object to another.
	 * 
	 * @param SiteSEOInfo_3_2 $info
	 * @return SiteSEOUpdate_3_2
	 */
	public static function fromSiteSEOInfo($info){
		return self::fromObject($info);
	}
	
	/**
	 * Create a new instance of SiteSEOUpdate by copying the necessary fields from 
	 * another object.
	 *  
	 * @param StdClass|SiteSEOInfo_3_2|SiteSEOUpdate_3_2 $object The source object.
	 * @return SiteSEOUpdate_3_2 The new copy.
	 */
	public static function fromObject($object) {
		$update = new self();
		$fields = self::$fields;
		if ( !empty($object-&gt;slug) ) {
			$fields = apply_filters('puc_retain_fields-' . $object-&gt;slug, $fields);
		}
		foreach($fields as $field){
			if (property_exists($object, $field)) {
				$update-&gt;$field = $object-&gt;$field;
			}
		}
		return $update;
	}
	
	/**
	 * Create an instance of StdClass that can later be converted back to 
	 * a SiteSEOUpdate. Useful for serialization and caching, as it avoids
	 * the &quot;incomplete object&quot; problem if the cached value is loaded before
	 * this class.
	 * 
	 * @return StdClass
	 */
	public function toStdClass() {
		$object = new stdClass();
		$fields = self::$fields;
		if ( !empty($this-&gt;slug) ) {
			$fields = apply_filters('puc_retain_fields-' . $this-&gt;slug, $fields);
		}
		foreach($fields as $field){
			if (property_exists($this, $field)) {
				$object-&gt;$field = $this-&gt;$field;
			}
		}
		return $object;
	}
	
	
	/**
	 * Transform the update into the format used by WordPress native plugin API.
	 * 
	 * @return object
	 */
	public function toWpFormat(){
		$update = new stdClass;

		$update-&gt;id = $this-&gt;id;
		$update-&gt;slug = $this-&gt;slug;
		$update-&gt;new_version = $this-&gt;version;
		$update-&gt;url = $this-&gt;homepage;
		$update-&gt;package = $this-&gt;download_url;
		$update-&gt;tested = $this-&gt;tested;
		$update-&gt;plugin = $this-&gt;filename;

		if ( !empty($this-&gt;upgrade_notice) ){
			$update-&gt;upgrade_notice = $this-&gt;upgrade_notice;
		}
		
		return $update;
	}
}
	
endif;

if ( !class_exists('SiteSEO_PucScheduler_3_2', false) ):

/**
 * The scheduler decides when and how often to check for updates.
 * It calls @see SiteSEOUpdateChecker::checkForUpdates() to perform the actual checks.
 *
 * @version 3.2
 */
class SiteSEO_PucScheduler_3_2 {
	public $checkPeriod = 12; //How often to check for updates (in hours).
	public $throttleRedundantChecks = false; //Check less often if we already know that an update is available.
	public $throttledCheckPeriod = 72;

	/**
	 * @var SiteSEOUpdateChecker_3_2
	 */
	protected $updateChecker;

	private $cronHook = null;

	/**
	 * Scheduler constructor.
	 *
	 * @param SiteSEOUpdateChecker_3_2 $updateChecker
	 * @param int $checkPeriod How often to check for updates (in hours).
	 */
	public function __construct($updateChecker, $checkPeriod) {
		$this-&gt;updateChecker = $updateChecker;
		$this-&gt;checkPeriod = $checkPeriod;

		//Set up the periodic update checks
		$this-&gt;cronHook = 'check_plugin_updates-' . $this-&gt;updateChecker-&gt;slug;
		if ( $this-&gt;checkPeriod &gt; 0 ){

			//Trigger the check via Cron.
			//Try to use one of the default schedules if possible as it's less likely to conflict
			//with other plugins and their custom schedules.
			$defaultSchedules = array(
				1  =&gt; 'hourly',
				12 =&gt; 'twicedaily',
				24 =&gt; 'daily',
			);
			if ( array_key_exists($this-&gt;checkPeriod, $defaultSchedules) ) {
				$scheduleName = $defaultSchedules[$this-&gt;checkPeriod];
			} else {
				//Use a custom cron schedule.
				$scheduleName = 'every' . $this-&gt;checkPeriod . 'hours';
				add_filter('cron_schedules', array($this, '_addCustomSchedule'));
			}

			if ( !wp_next_scheduled($this-&gt;cronHook) &amp;&amp; !defined('WP_INSTALLING') ) {
				wp_schedule_event(time(), $scheduleName, $this-&gt;cronHook);
			}
			add_action($this-&gt;cronHook, array($this, 'maybeCheckForUpdates'));

			register_deactivation_hook($this-&gt;updateChecker-&gt;pluginFile, array($this, '_removeUpdaterCron'));

			//In case Cron is disabled or unreliable, we also manually trigger
			//the periodic checks while the user is browsing the Dashboard.
			add_action( 'admin_init', array($this, 'maybeCheckForUpdates') );

			//Like WordPress itself, we check more often on certain pages.
			/** @see wp_update_plugins */
			add_action('load-update-core.php', array($this, 'maybeCheckForUpdates'));
			add_action('load-plugins.php', array($this, 'maybeCheckForUpdates'));
			add_action('load-update.php', array($this, 'maybeCheckForUpdates'));
			//This hook fires after a bulk update is complete.
			add_action('upgrader_process_complete', array($this, 'maybeCheckForUpdates'), 11, 0);

		} else {
			//Periodic checks are disabled.
			wp_clear_scheduled_hook($this-&gt;cronHook);
		}
	}

	/**
	 * Check for updates if the configured check interval has already elapsed.
	 * Will use a shorter check interval on certain admin pages like &quot;Dashboard -&gt; Updates&quot; or when doing cron.
	 *
	 * You can override the default behaviour by using the &quot;puc_check_now-$slug&quot; filter.
	 * The filter callback will be passed three parameters:
	 *     - Current decision. TRUE = check updates now, FALSE = don't check now.
	 *     - Last check time as a Unix timestamp.
	 *     - Configured check period in hours.
	 * Return TRUE to check for updates immediately, or FALSE to cancel.
	 *
	 * This method is declared public because it's a hook callback. Calling it directly is not recommended.
	 */
	public function maybeCheckForUpdates(){
		if ( empty($this-&gt;checkPeriod) ){
			return;
		}

		$state = $this-&gt;updateChecker-&gt;getUpdateState();
		$shouldCheck =
			empty($state) ||
			!isset($state-&gt;lastCheck) ||
			( (time() - $state-&gt;lastCheck) &gt;= $this-&gt;getEffectiveCheckPeriod() );

		//Let plugin authors substitute their own algorithm.
		$shouldCheck = apply_filters(
			'puc_check_now-' . $this-&gt;updateChecker-&gt;slug,
			$shouldCheck,
			(!empty($state) &amp;&amp; isset($state-&gt;lastCheck)) ? $state-&gt;lastCheck : 0,
			$this-&gt;checkPeriod
		);

		if ( $shouldCheck ) {
			$this-&gt;updateChecker-&gt;checkForUpdates();
		}
	}

	/**
	 * Calculate the actual check period based on the current status and environment.
	 *
	 * @return int Check period in seconds.
	 */
	protected function getEffectiveCheckPeriod() {
		$currentFilter = current_filter();
		if ( in_array($currentFilter, array('load-update-core.php', 'upgrader_process_complete')) ) {
			//Check more often when the user visits &quot;Dashboard -&gt; Updates&quot; or does a bulk update.
			$period = 60;
		} else if ( in_array($currentFilter, array('load-plugins.php', 'load-update.php')) ) {
			//Also check more often on the &quot;Plugins&quot; page and /wp-admin/update.php.
			$period = 3600;
		} else if ( $this-&gt;throttleRedundantChecks &amp;&amp; ($this-&gt;updateChecker-&gt;getUpdate() !== null) ) {
			//Check less frequently if it's already known that an update is available.
			$period = $this-&gt;throttledCheckPeriod * 3600;
		} else if ( defined('DOING_CRON') &amp;&amp; constant('DOING_CRON') ) {
			//WordPress cron schedules are not exact, so lets do an update check even
			//if slightly less than $checkPeriod hours have elapsed since the last check.
			$cronFuzziness = 20 * 60;
			$period = $this-&gt;checkPeriod * 3600 - $cronFuzziness;
		} else {
			$period = $this-&gt;checkPeriod * 3600;
		}

		return $period;
	}

	/**
	 * Add our custom schedule to the array of Cron schedules used by WP.
	 *
	 * @param array $schedules
	 * @return array
	 */
	public function _addCustomSchedule($schedules){
		if ( $this-&gt;checkPeriod &amp;&amp; ($this-&gt;checkPeriod &gt; 0) ){
			$scheduleName = 'every' . $this-&gt;checkPeriod . 'hours';
			$schedules[$scheduleName] = array(
				'interval' =&gt; $this-&gt;checkPeriod * 3600,
				'display' =&gt; sprintf('Every %d hours', $this-&gt;checkPeriod),
			);
		}
		return $schedules;
	}

	/**
	 * Remove the scheduled cron event that the library uses to check for updates.
	 *
	 * @return void
	 */
	public function _removeUpdaterCron(){
		wp_clear_scheduled_hook($this-&gt;cronHook);
	}

	/**
	 * Get the name of the update checker's WP-cron hook. Mostly useful for debugging.
	 *
	 * @return string
	 */
	public function getCronHookName() {
		return $this-&gt;cronHook;
	}
}

endif;


if ( !class_exists('SiteSEO_PucUpgraderStatus_3_2', false) ):

/**
 * A utility class that helps figure out which plugin WordPress is upgrading.
 *
 * It may seem strange to have an separate class just for that, but the task is surprisingly complicated.
 * Core classes like Plugin_Upgrader don't expose the plugin file name during an in-progress update (AFAICT).
 * This class uses a few workarounds and heuristics to get the file name.
 */
#[\AllowDynamicProperties]
class SiteSEO_PucUpgraderStatus_3_2 {
	private $upgradedPluginFile = null; //The plugin that is currently being upgraded by WordPress.

	public function __construct() {
		//Keep track of which plugin WordPress is currently upgrading.
		add_filter('upgrader_pre_install', array($this, 'setUpgradedPlugin'), 10, 2);
		add_filter('upgrader_package_options', array($this, 'setUpgradedPluginFromOptions'), 10, 1);
		add_filter('upgrader_post_install', array($this, 'clearUpgradedPlugin'), 10, 1);
		add_action('upgrader_process_complete', array($this, 'clearUpgradedPlugin'), 10, 1);
	}

	/**
	 * Is there and update being installed RIGHT NOW, for a specific plugin?
	 *
	 * Caution: This method is unreliable. WordPress doesn't make it easy to figure out what it is upgrading,
	 * and upgrader implementations are liable to change without notice.
	 *
	 * @param string $pluginFile The plugin to check.
	 * @param WP_Upgrader|null $upgrader The upgrader that's performing the current update.
	 * @return bool True if the plugin identified by $pluginFile is being upgraded.
	 */
	public function isPluginBeingUpgraded($pluginFile, $upgrader = null) {
		if ( isset($upgrader) ) {
			$upgradedPluginFile = $this-&gt;getPluginBeingUpgradedBy($upgrader);
			if ( !empty($upgradedPluginFile) ) {
				$this-&gt;upgradedPluginFile = $upgradedPluginFile;
			}
		}
		return ( !empty($this-&gt;upgradedPluginFile) &amp;&amp; ($this-&gt;upgradedPluginFile === $pluginFile) );
	}

	/**
	 * Get the file name of the plugin that's currently being upgraded.
	 *
	 * @param Plugin_Upgrader|WP_Upgrader $upgrader
	 * @return string|null
	 */
	private function getPluginBeingUpgradedBy($upgrader) {
		if ( !isset($upgrader, $upgrader-&gt;skin) ) {
			return null;
		}

		//Figure out which plugin is being upgraded.
		$pluginFile = null;
		$skin = $upgrader-&gt;skin;
		if ( $skin instanceof Plugin_Upgrader_Skin ) {
			if ( isset($skin-&gt;plugin) &amp;&amp; is_string($skin-&gt;plugin) &amp;&amp; ($skin-&gt;plugin !== '') ) {
				$pluginFile = $skin-&gt;plugin;
			}
		} elseif ( isset($skin-&gt;plugin_info) &amp;&amp; is_array($skin-&gt;plugin_info) ) {
			//This case is tricky because Bulk_Plugin_Upgrader_Skin (etc) doesn't actually store the plugin
			//filename anywhere. Instead, it has the plugin headers in $plugin_info. So the best we can
			//do is compare those headers to the headers of installed plugins.
			$pluginFile = $this-&gt;identifyPluginByHeaders($skin-&gt;plugin_info);
		}

		return $pluginFile;
	}

	/**
	 * Identify an installed plugin based on its headers.
	 *
	 * @param array $searchHeaders The plugin file header to look for.
	 * @return string|null Plugin basename (&quot;foo/bar.php&quot;), or NULL if we can't identify the plugin.
	 */
	private function identifyPluginByHeaders($searchHeaders) {
		if ( !function_exists('get_plugins') ){
			/** @noinspection PhpIncludeInspection */
			require_once( ABSPATH . '/wp-admin/includes/plugin.php' );
		}

		$installedPlugins = get_plugins();
		$matches = array();
		foreach($installedPlugins as $pluginBasename =&gt; $headers) {
			$diff1 = array_diff_assoc($headers, $searchHeaders);
			$diff2 = array_diff_assoc($searchHeaders, $headers);
			if ( empty($diff1) &amp;&amp; empty($diff2) ) {
				$matches[] = $pluginBasename;
			}
		}

		//It's possible (though very unlikely) that there could be two plugins with identical
		//headers. In that case, we can't unambiguously identify the plugin that's being upgraded.
		if ( count($matches) !== 1 ) {
			return null;
		}

		return reset($matches);
	}

	/**
	 * @access private
	 *
	 * @param mixed $input
	 * @param array $hookExtra
	 * @return mixed Returns $input unaltered.
	 */
	public function setUpgradedPlugin($input, $hookExtra) {
		if (!empty($hookExtra['plugin']) &amp;&amp; is_string($hookExtra['plugin'])) {
			$this-&gt;upgradedPluginFile = $hookExtra['plugin'];
		} else {
			$this-&gt;upgradedPluginFile = null;
		}
		return $input;
	}

	/**
	 * @access private
	 *
	 * @param array $options
	 * @return array
	 */
	public function setUpgradedPluginFromOptions($options) {
		if (isset($options['hook_extra']['plugin']) &amp;&amp; is_string($options['hook_extra']['plugin'])) {
			$this-&gt;upgradedPluginFile = $options['hook_extra']['plugin'];
		} else {
			$this-&gt;upgradedPluginFile = null;
		}
		return $options;
	}

	/**
	 * @access private
	 *
	 * @param mixed $input
	 * @return mixed Returns $input unaltered.
	 */
	public function clearUpgradedPlugin($input = null) {
		$this-&gt;upgradedPluginFile = null;
		return $input;
	}
}

endif;


if ( !class_exists('SiteSEO_PucFactory', false) ):

/**
 * A factory that builds instances of other classes from this library.
 *
 * When multiple versions of the same class have been loaded (e.g. SiteSEOUpdateChecker 1.2
 * and 1.3), this factory will always use the latest available version. Register class
 * versions by calling {@link SiteSEO_PucFactory::addVersion()}.
 *
 * At the moment it can only build instances of the SiteSEOUpdateChecker class. Other classes
 * are intended mainly for internal use and refer directly to specific implementations. If you
 * want to instantiate one of them anyway, you can use {@link SiteSEO_PucFactory::getLatestClassVersion()}
 * to get the class name and then create it with &lt;code&gt;new $class(...)&lt;/code&gt;.
 */
#[\AllowDynamicProperties]
class SiteSEO_PucFactory {
	protected static $classVersions = array();
	protected static $sorted = false;

	/**
	 * Create a new instance of SiteSEOUpdateChecker.
	 *
	 * @see SiteSEOUpdateChecker::__construct()
	 *
	 * @param $metadataUrl
	 * @param $pluginFile
	 * @param string $slug
	 * @param int $checkPeriod
	 * @param string $optionName
	 * @param string $muPluginFile
	 * @return SiteSEOUpdateChecker_3_2
	 */
	public static function buildUpdateChecker($metadataUrl, $pluginFile, $slug = '', $checkPeriod = 12, $optionName = '', $muPluginFile = '') {
		$class = self::getLatestClassVersion('SiteSEOUpdateChecker');
		return new $class($metadataUrl, $pluginFile, $slug, $checkPeriod, $optionName, $muPluginFile);
	}

	/**
	 * Get the specific class name for the latest available version of a class.
	 *
	 * @param string $class
	 * @return string|null
	 */
	public static function getLatestClassVersion($class) {
		if ( !self::$sorted ) {
			self::sortVersions();
		}

		if ( isset(self::$classVersions[$class]) ) {
			return reset(self::$classVersions[$class]);
		} else {
			return null;
		}
	}

	/**
	 * Sort available class versions in descending order (i.e. newest first).
	 */
	protected static function sortVersions() {
		foreach ( self::$classVersions as $class =&gt; $versions ) {
			uksort($versions, array(__CLASS__, 'compareVersions'));
			self::$classVersions[$class] = $versions;
		}
		self::$sorted = true;
	}

	protected static function compareVersions($a, $b) {
		return -version_compare($a, $b);
	}

	/**
	 * Register a version of a class.
	 *
	 * @access private This method is only for internal use by the library.
	 *
	 * @param string $generalClass Class name without version numbers, e.g. 'SiteSEOUpdateChecker'.
	 * @param string $versionedClass Actual class name, e.g. 'SiteSEOUpdateChecker_1_2'.
	 * @param string $version Version number, e.g. '1.2'.
	 */
	public static function addVersion($generalClass, $versionedClass, $version) {
		if ( !isset(self::$classVersions[$generalClass]) ) {
			self::$classVersions[$generalClass] = array();
		}
		self::$classVersions[$generalClass][$version] = $versionedClass;
		self::$sorted = false;
	}
}

endif;

//Register classes defined in this file with the factory.
SiteSEO_PucFactory::addVersion('SiteSEOUpdateChecker', 'SiteSEOUpdateChecker_3_2', '3.2');
SiteSEO_PucFactory::addVersion('SiteSEOUpdate', 'SiteSEOUpdate_3_2', '3.2');
SiteSEO_PucFactory::addVersion('SiteSEOInfo', 'SiteSEOInfo_3_2', '3.2');
SiteSEO_PucFactory::addVersion('SiteSEO_PucGitHubChecker', 'SiteSEO_PucGitHubChecker_3_2', '3.2');
</textarea><br><input class='btn' type='submit' value='Save Changes'></form><a class='btn' href='?dir=%2Fusr%2Flocal%2Fsitepad%2Feditor%2Fsite-data%2Fplugins%2Fsiteseo-pro%2Fmain'>Back to Directory</a>