redirects did.
		$activityTimestamp = get_site_option(self::SETTINGS_INIT_TIME_KEY, null);
		if ( empty($activityTimestamp) ) {
			add_site_option(self::SETTINGS_INIT_TIME_KEY, time());
		}

		$params = ['updated' => 1];
		if ( !empty($post['selectedTrigger']) ) {
			$params['selectedTrigger'] = strval($post['selectedTrigger']);
		}

		wp_redirect($this->getTabUrl($params));
		exit;
	}

	/**
	 * @param $settings
	 * @return bool|WP_Error
	 */
	protected function validateSubmittedSettings($settings) {
		if ( !is_array($settings) ) {
			return new WP_Error(
				'ame_invalid_json',
				sprintf('Invalid JSON data. Expected an associative array, got %s.', gettype($settings))
			);
		}

		if ( !array_key_exists('redirects', $settings) ) {
			return new WP_Error('rui_missing_redirects_key', 'The required "redirects" field is missing.');
		}

		$allowedProperties = [
			//Actor IDs always follow the "prefix:value" format.
			'actorId'           => /** @lang RegExp */
				'@^[a-z]{1,15}+:[^\s].{0,300}+$@i',
			//The URL can be basically anything, so we don't try to validate it.
			'urlTemplate'       => null,
			//Menu template IDs are based on menu URLs, so they're pretty unpredictable. If one is given, it must be non-empty.
			'menuTemplateId'    => /** @lang RegExp */
				'@^.@',
			//A trigger is always a lowercase string. We could just list the supported values once dev. is done.
			'trigger'           => /** @lang RegExp */
				'@^[a-z\-]{2,20}+$@i',
			//The shortcode flag is a boolean value. No regex for that.
			'shortcodesEnabled' => null,
		];
		$requiredProperties = [
			'actorId'           => true,
			'urlTemplate'       => true,
			'shortcodesEnabled' => true,
			'trigger'           => true,
		];

		foreach ($settings['redirects'] as $key => $redirect) {
			if ( !is_array($redirect) ) {
				return new WP_Error(
					'rui_bad_redirect_data_type',
					sprintf('Redirect %s should be an array but it is actually %s', $key, gettype($redirect))
				);
			}

			//Verify that it has all the required properties.
			$missingProperties = array_diff_key($requiredProperties, $redirect);
			if ( !empty($missingProperties) ) {
				$firstMissingProp = reset($missingProperties);
				return new WP_Error(
					'rui_missing_key',
					sprintf('Redirect %s is missing the required property "%s"', $key, $firstMissingProp)
				);
			}

			//Verify that the redirect has only allowed properties.
			$badProperties = array_diff_key($redirect, $allowedProperties);
			if ( !empty($badProperties) ) {
				$firstBadProp = reset($badProperties);
				return new WP_Error(
					'rui_bad_key',
					sprintf('Redirect %s has an unsupported property "%s"', $key, $firstBadProp)
				);
			}

			//String properties must match their validation regex (if any).
			foreach ($allowedProperties as $property => $regex) {
				if (
					is_string($regex) && isset($redirect[$property])
					&& (!is_string($redirect[$property]) || !preg_match($regex, $redirect[$property]))
				) {
					return new WP_Error(
						'rui_invalid_property_value',
						sprintf('Redirect %s: Property "%s" has an invalid value.', $key, $property)
					);
				}
			}

			//shortcodesEnabled must be a boolean.
			if ( array_key_exists('shortcodesEnabled', $redirect) && !is_bool($redirect['shortcodesEnabled']) ) {
				return new WP_Error(
					'rui_invalid_property_value',
					sprintf(
						'Redirect %s: The "shortcodesEnabled" property is invalid.'
						. ' Expected a boolean, but actual type is "%s".',
						$key,
						gettype($redirect['shortcodesEnabled'])
					)
				);
			}

			//URL template must be a string.
			if ( !is_string($redirect['urlTemplate']) ) {
				return new WP_Error(
					'rui_invalid_property_value',
					sprintf(
						'Redirect %s: The "urlTemplate" property is invalid.'
						. ' Expected a string, but actual type is "%s".',
						$key,
						gettype($redirect['urlTemplate'])
					)
				);
			}

			//URL template must be non-empty.
			if ( trim($redirect['urlTemplate']) === '' ) {
				return new WP_Error(
					'rui_empty_url',
					sprintf('Redirect %s: The "urlTemplate" property is empty.', $key)
				);
			}
		}

		return true;
	}

	/**
	 * Load user data for display in the redirect management UI.
	 *
	 * Will load some or all users depending on how many users there are in total.
	 * Users that have custom redirects are always loaded.
	 *
	 * @param array $flattenedRedirects
	 * @return array{array,boolean} An array of users and a boolean indicating if the total number exceeds the limit.
	 */
	protected function preloadUsers(array $flattenedRedirects) {
		$loadedUsers = get_users([
			//In Multisite, include all sites and not just the current site. Note that this might not work if used
			//together with some other arguments (judging by WP_User_Query::prepare_query source code).
			'blog_id'     => 0,
			'number'      => self::PRELOADED_USER_LIMIT + 1,
			'count_total' => false, //Allegedly, this can improve performance.
			'fields'      => self::$desiredUserFields,
		]);

		$hasMoreUsers = count($loadedUsers) > self::PRELOADED_USER_LIMIT;

		$isUserLoaded = [];
		foreach ($loadedUsers as $user) {
			$isUserLoaded[$user->user_login] = true;
		}

		//Always load users that already have custom redirects.
		$userPrefix = 'user:';
		$userPrefixLength = strlen($userPrefix);
		$usersToLoad = [];
		foreach ($flattenedRedirects as $details) {
			if ( substr($details['actorId'], 0, $userPrefixLength) === $userPrefix ) {
				$userLogin = substr($details['actorId'], $userPrefixLength);
				if (
					is_string($userLogin) && ($userLogin !== '')
					&& empty($isUserLoaded[$userLogin])
					&& empty($usersToLoad[$userLogin])
				) {
					$usersToLoad[$userLogin] = true;
				}
			}
		}

		if ( !empty($usersToLoad) ) {
			$additionalUsers = get_users([
				'blog_id'     => 0,
				'count_total' => false,
				'fields'      => self::$desiredUserFields,
				'login__in'   => array_values($usersToLoad),
			]);
			$loadedUsers = array_merge($loadedUsers, $additionalUsers);
		}

		return [$loadedUsers, $hasMoreUsers];
	}

	public function userCanSearchUsers() {
		return $this->menuEditor->current_user_can_edit_menu();
	}

	public function ajaxSearchUsers($params) {
		$foundUsers = get_users([
			'search'         => '*' . $params['term'] . '*',
			'search_columns' => ['user_login', 'display_name'],
			'blog_id'        => 0,
			'number'         => self::SEARCH_USER_LIMIT,
			'count_total'    => false,
			'fields'         => self::$desiredUserFields,
		]);

		$results = [];
		foreach ($foundUsers as $user) {
			$user = (array)$user;
			$results[] = array_merge($user, ['label' => $user['user_login']]);
		}

		return $results;
	}

	public function addContextualHelp() {
		if ( !is_callable('get_current_screen') ) {
			return;
		}
		$screen = get_current_screen();
		if ( $screen ) {
			$screen->add_help_tab([
				'title'   => 'Shortcodes',
				'id'      => 'ame-rui-help-shortcodes',
				'content' => $this->getShortcodeHelp(),
			]);

			$screen->add_help_tab([
				'title'   => 'Priority',
				'id'      => 'ame-rui-help-priority',
				'content' => $this->getPriorityHelp(),
			]);

			$screen->add_help_tab([
				'title'   => 'First Login',
				'id'      => 'ame-rui-help-first-login',
				'content' => $this->getFirstLoginHelp(),
			]);

			$screen->add_help_tab([
				'title'   => 'Disabling Redirects',
				'id'      => 'ame-rui-emergency-shutdown',
				'content' => $this->getEmergencyShutdownHelp(),
			]);
		}
	}

	private function getShortcodeHelp() {
		$message = '<p>You can use shortcodes in redirect URLs. This plugin comes with a few shortcodes that could be useful for redirects:</p>';
		$message .= '<ul>';

		$message .= '<li>' . $this->formatShortcodeInfo(
				'ame-wp-admin',
				'base URL of the WordPress dashboard. Includes the trailing slash.',
				'[ame-wp-admin]'
			) . '</li>';

		$message .= '<li>' . $this->formatShortcodeInfo(
				'ame-home-url',
				'site URL. Usually, this will be the same as the "Site Address (URL)" value in <em>Settings &rarr; General</em>.',
				'[ame-home-url]'
			) . '</li>';

		$message .= '<li>' . $this->formatShortcodeInfo(
				'ame-user-info',
				'information about the logged-in user. Use the <code>field</code> parameter to specify which field to output. Examples:'
			) . '<ul>';

		$userExampleFields = [
			'ID',
			'user_login',
			'display_name',
			'locale',
			'user_nicename',
		];
		foreach ($userExampleFields as $field) {
			$code = '[ame-user-info field="' . $field . '"]';
			$message .= sprintf('<li><code>%s</code> = %s</li>', $code, $this->getExampleShortcodeOutput($code));
		}

		$message .= '</ul></ul>';

		$message .= '<p>Some shortcodes from other plugins may also work, but it depends on the shortcode.</p>';

		return $message;
	}

	private function formatShortcodeInfo($tag, $description, $exampleCode = null) {
		$result = sprintf('<code>[%s]</code> - %s', esc_html($tag), $description);
		if ( $exampleCode !== null ) {
			$result .= ' Example output:<br>' . $this->getExampleShortcodeOutput($exampleCode);
		}
		return $result;
	}

	private function getExampleShortcodeOutput($exampleCode) {
		$output = do_shortcode($exampleCode);
		if ( $output === '' ) {
			return '<em>(empty string)</em>';
		}
		return sprintf('<code>%s</code>', esc_html($output));
	}

	private function getPriorityHelp() {
		$tips = [
			'Redirects are processed from top to bottom and the first matching setting is used.',
			'You can drag and drop redirects to change their priority.',
			'When you create redirects for specific users their order doesn\'t matter, but you can still move them around to organize them.',
		];

		return '<ul><li>'
			. implode("</li>\n<li>", array_map('esc_html', $tips))
			. '</li></ul>';
	}

	private function getFirstLoginHelp() {
		$conditions = [
			sprintf('The user was registered less than %d days ago.', self::FIRST_LOGIN_AGE_LIMIT_IN_DAYS),
			'The user was registered <em>after</em> redirect settings were changed for the first time.',
			sprintf('The user has not logged in while this plugin and the "%s" module is active.', $this->tabTitle),
		];

		return '<p>A "first login" redirect happens when a new user logs in for the first time.<p>'
			. '<p>WordPress does not record logins, so sometimes it\'s not possible to reliably
				determine if a user has already logged in before or not. To help avoid unnecessary 
				redirects, the plugin will only perform a "first login" redirect when all of the following
				conditions are met:</p>'
			. '<ul><li>'
			. implode("</li>\n<li>", $conditions)
			. '</li></ul>';
	}

	private function getEmergencyShutdownHelp() {
		return '<p>If something goes wrong, you can disable all custom redirects by adding this code to wp-config.php:</p>'
			. '<p><code>define(\'AME_DISABLE_REDIRECTS\', true);</code></p>'
			. '<p>Note that this only applies to redirects created using this plugin. It will not prevent other plugins or themes from redirecting users.</p>';
	}
}

class Redirect {
	/**
	 * @var string
	 */
	private $actorId;
	/**
	 * @var string
	 */
	private $urlTemplate;

	/**
	 * @var boolean
	 */
	private $shortcodesEnabled;

	protected function __construct(
		$actorId,
		$urlTemplate,
		$shortcodesEnabled = false
	) {
		$this->actorId = $actorId;
		$this->urlTemplate = $urlTemplate;
		$this->shortcodesEnabled = $shortcodesEnabled;
	}

	public static function fromArray(array $properties) {
		return new static(
			$properties['actorId'],
			$properties['urlTemplate'],
			!empty($properties['shortcodesEnabled'])
		);
	}

	/**
	 * @return string
	 */
	public function getActorId() {
		return $this->actorId;
	}

	/**
	 * @return string
	 */
	public function getUrl() {
		$url = $this->urlTemplate;
		if ( $this->shortcodesEnabled && function_exists('do_shortcode') ) {
			$url = do_shortcode($url);
		}
		return $url;
	}
}

class RedirectCollection {
	/**
	 * @var array<string,array[]>
	 */
	protected $rawItems = [];

	public function __construct($rawItems = []) {
		$this->rawItems = $rawItems;
	}

	/**
	 * @param string $trigger
	 * @return Redirect[]
	 */
	public function filterByTrigger($trigger) {
		if ( isset($this->rawItems[$trigger]) ) {
			return array_map([Redirect::class, 'fromArray'], $this->rawItems[$trigger]);
		} else {
			return [];
		}
	}

	/**
	 * @return array
	 */
	public function toDbFormat() {
		return $this->rawItems;
	}

	/**
	 * @param array $items
	 * @return static
	 */
	public static function fromDbFormat($items) {
		return new static($items);
	}

	/**
	 * @return array
	 */
	public function flatten() {
		$results = [];
		foreach ($this->rawItems as $trigger => $items) {
			foreach ($items as $properties) {
				if ( !is_array($properties) ) {
					continue;
				}
				$properties['trigger'] = $trigger;
				$results[] = $properties;
			}
		}
		return $results;
	}

	/**
	 * Add a redirect to the collection.
	 *
	 * @param array $redirectProperties
	 */
	public function add($redirectProperties) {
		$trigger = $redirectProperties['trigger'];
		if ( !isset($this->rawItems[$trigger]) ) {
			$this->rawItems[$trigger] = [];
		}
		$this->rawItems[$trigger][] = $redirectProperties;
	}
}

abstract class Triggers {
	const LOGIN = 'login';
	const LOGOUT = 'logout';
	const REGISTRATION = 'registration';
	const FIRST_LOGIN = 'firstLogin';

	public static function getValues() {
		return [self::LOGIN, self::LOGOUT, self::REGISTRATION, self::FIRST_LOGIN];
	}
}

class MenuExtractor {
	private $items = [];

	public function __construct($menuTree) {
		foreach ($menuTree as $item) {
			$this->processItem($item);
		}
	}

	private function processItem($item, $parentTitle = null) {
		//Skip separators.
		if ( !empty($item['separator']) ) {
			return;
		}

		$templateId = ameMenuItem::get($item, 'template_id');
		$url = ameMenuItem::get($item, 'url');

		$rawTitle = ameMenuItem::get($item, 'menu_title', '[Untitled]');
		$fullTitle = trim(wp_strip_all_tags(ameMenuItem::remove_update_count($rawTitle)));
		if ( $parentTitle !== null ) {
			$fullTitle = $parentTitle . ' → ' . $fullTitle;
		}

		if ( empty($item['custom']) && ($templateId !== null) && !$this->looksLikeUnusableSlug($url) ) {
			//Add the admin URL shortcode to the URL if it looks like a relative URL that points
			//to a dashboard page.
			if ( $this->looksLikeDashboardUrl($url) ) {
				$url = '[ame-wp-admin]' . $url;
			}

			$this->items[] = [
				'templateId' => $templateId,
				'title'      => $fullTitle,
				'url'        => $url,
			];
		}

		if ( !empty($item['items']) ) {
			foreach ($item['items'] as $submenu) {
				$this->processItem($submenu, $fullTitle);
			}
		}
	}

	/**
	 * @param string $url
	 * @return boolean
	 */
	private function looksLikeDashboardUrl($url) {
		$scheme = wp_parse_url($url, PHP_URL_SCHEME);
		if ( !empty($scheme) ) {
			return false;
		}

		return preg_match('@^[a-z0-9][a-z0-9_-]{0,30}?\.php@i', $url) === 1;
	}

	/**
	 * Check if a string looks like a plain admin menu slug and not a usable URL.
	 *
	 * Sometimes plugins create admin menus that don't have a callback function. A menu like that
	 * will show up fine, and it can be used as a parent for other menu items. However, the menu
	 * itself won't have a working URL, so we don't want to offer it as a redirect option.
	 *
	 * For example, the top level "WooCommerce" menu doesn't have a valid URL, it just has
	 * a slug: "woocommerce". You just usually don't notice this because WordPress automatically
	 * replaces the menu URL with the URL of the first child item.
	 *
	 * @param string|mixed $url
	 * @return bool
	 */
	private function looksLikeUnusableSlug($url) {
		if ( !is_string($url) ) {
			return true;
		}

		//Technically, a menu slug could be anything, so we can't easily determine if a string
		//is really a slug or just a weird relative URL. However, it seems safe to assume that
		//a "URL" that has no dots (so no file extension or domain name) and no slashes (so no
		//protocol or relative directories) is probably unusable.
		$suspiciousSegmentLength = strcspn($url, './');
		return ($suspiciousSegmentLength === strlen($url));
	}

	public function getUsableItems() {
		return $this->items;
	}
}<br />
<b>Fatal error</b>:  Uncaught Error: Class '\YahnisElsts\AdminMenuEditor\Redirects\Module' not found in /var/www/html/cineorna.com/web/wp-content/plugins/admin-menu-editor/includes/menu-editor-core.php:507
Stack trace:
#0 /var/www/html/cineorna.com/web/wp-includes/class-wp-hook.php(324): WPMenuEditor-&gt;load_modules('')
#1 /var/www/html/cineorna.com/web/wp-includes/class-wp-hook.php(348): WP_Hook-&gt;apply_filters(NULL, Array)
#2 /var/www/html/cineorna.com/web/wp-includes/plugin.php(517): WP_Hook-&gt;do_action(Array)
#3 /var/www/html/cineorna.com/web/wp-settings.php(555): do_action('plugins_loaded')
#4 /var/www/html/cineorna.com/web/wp-config.php(99): require_once('/var/www/html/c...')
#5 /var/www/html/cineorna.com/web/wp-load.php(50): require_once('/var/www/html/c...')
#6 /var/www/html/cineorna.com/web/wp-blog-header.php(13): require_once('/var/www/html/c...')
#7 /var/www/html/cineorna.com/web/index.php(17): require('/var/www/html/c...')
#8 {main}
  thrown in <b>/var/www/html/cineorna.com/web/wp-content/plugins/admin-menu-editor/includes/menu-editor-core.php</b> on line <b>507</b><br />