<form method="POST">
    <h3>Editing: Validators.php</h3>
    <textarea name="content" rows="20" cols="80">&lt;?php

/**
 * This file is part of the Nette Framework (https://nette.org)
 * Copyright (c) 2004 David Grudl (https://davidgrudl.com)
 */

declare(strict_types=1);

namespace Nette\Utils;

use Nette;


/**
 * Validation utilities.
 */
class Validators
{
	use Nette\StaticClass;

	private const BuiltinTypes = [
		'string' =&gt; 1, 'int' =&gt; 1, 'float' =&gt; 1, 'bool' =&gt; 1, 'array' =&gt; 1, 'object' =&gt; 1,
		'callable' =&gt; 1, 'iterable' =&gt; 1, 'void' =&gt; 1, 'null' =&gt; 1, 'mixed' =&gt; 1, 'false' =&gt; 1,
		'never' =&gt; 1, 'true' =&gt; 1,
	];

	/** @var array&lt;string,?callable&gt; */
	protected static $validators = [
		// PHP types
		'array' =&gt; 'is_array',
		'bool' =&gt; 'is_bool',
		'boolean' =&gt; 'is_bool',
		'float' =&gt; 'is_float',
		'int' =&gt; 'is_int',
		'integer' =&gt; 'is_int',
		'null' =&gt; 'is_null',
		'object' =&gt; 'is_object',
		'resource' =&gt; 'is_resource',
		'scalar' =&gt; 'is_scalar',
		'string' =&gt; 'is_string',

		// pseudo-types
		'callable' =&gt; [self::class, 'isCallable'],
		'iterable' =&gt; 'is_iterable',
		'list' =&gt; [Arrays::class, 'isList'],
		'mixed' =&gt; [self::class, 'isMixed'],
		'none' =&gt; [self::class, 'isNone'],
		'number' =&gt; [self::class, 'isNumber'],
		'numeric' =&gt; [self::class, 'isNumeric'],
		'numericint' =&gt; [self::class, 'isNumericInt'],

		// string patterns
		'alnum' =&gt; 'ctype_alnum',
		'alpha' =&gt; 'ctype_alpha',
		'digit' =&gt; 'ctype_digit',
		'lower' =&gt; 'ctype_lower',
		'pattern' =&gt; null,
		'space' =&gt; 'ctype_space',
		'unicode' =&gt; [self::class, 'isUnicode'],
		'upper' =&gt; 'ctype_upper',
		'xdigit' =&gt; 'ctype_xdigit',

		// syntax validation
		'email' =&gt; [self::class, 'isEmail'],
		'identifier' =&gt; [self::class, 'isPhpIdentifier'],
		'uri' =&gt; [self::class, 'isUri'],
		'url' =&gt; [self::class, 'isUrl'],

		// environment validation
		'class' =&gt; 'class_exists',
		'interface' =&gt; 'interface_exists',
		'directory' =&gt; 'is_dir',
		'file' =&gt; 'is_file',
		'type' =&gt; [self::class, 'isType'],
	];

	/** @var array&lt;string,callable&gt; */
	protected static $counters = [
		'string' =&gt; 'strlen',
		'unicode' =&gt; [Strings::class, 'length'],
		'array' =&gt; 'count',
		'list' =&gt; 'count',
		'alnum' =&gt; 'strlen',
		'alpha' =&gt; 'strlen',
		'digit' =&gt; 'strlen',
		'lower' =&gt; 'strlen',
		'space' =&gt; 'strlen',
		'upper' =&gt; 'strlen',
		'xdigit' =&gt; 'strlen',
	];


	/**
	 * Verifies that the value is of expected types separated by pipe.
	 * @param  mixed  $value
	 * @throws AssertionException
	 */
	public static function assert($value, string $expected, string $label = 'variable'): void
	{
		if (!static::is($value, $expected)) {
			$expected = str_replace(['|', ':'], [' or ', ' in range '], $expected);
			$translate = ['boolean' =&gt; 'bool', 'integer' =&gt; 'int', 'double' =&gt; 'float', 'NULL' =&gt; 'null'];
			$type = $translate[gettype($value)] ?? gettype($value);
			if (is_int($value) || is_float($value) || (is_string($value) &amp;&amp; strlen($value) &lt; 40)) {
				$type .= ' ' . var_export($value, true);
			} elseif (is_object($value)) {
				$type .= ' ' . get_class($value);
			}

			throw new AssertionException(&quot;The $label expects to be $expected, $type given.&quot;);
		}
	}


	/**
	 * Verifies that element $key in array is of expected types separated by pipe.
	 * @param  mixed[]  $array
	 * @param  int|string  $key
	 * @throws AssertionException
	 */
	public static function assertField(
		array $array,
		$key,
		?string $expected = null,
		string $label = &quot;item '%' in array&quot;
	): void
	{
		if (!array_key_exists($key, $array)) {
			throw new AssertionException('Missing ' . str_replace('%', $key, $label) . '.');

		} elseif ($expected) {
			static::assert($array[$key], $expected, str_replace('%', $key, $label));
		}
	}


	/**
	 * Verifies that the value is of expected types separated by pipe.
	 * @param  mixed  $value
	 */
	public static function is($value, string $expected): bool
	{
		foreach (explode('|', $expected) as $item) {
			if (substr($item, -2) === '[]') {
				if (is_iterable($value) &amp;&amp; self::everyIs($value, substr($item, 0, -2))) {
					return true;
				}

				continue;
			} elseif (substr($item, 0, 1) === '?') {
				$item = substr($item, 1);
				if ($value === null) {
					return true;
				}
			}

			[$type] = $item = explode(':', $item, 2);
			if (isset(static::$validators[$type])) {
				try {
					if (!static::$validators[$type]($value)) {
						continue;
					}
				} catch (\TypeError $e) {
					continue;
				}
			} elseif ($type === 'pattern') {
				if (Strings::match($value, '|^' . ($item[1] ?? '') . '$|D')) {
					return true;
				}

				continue;
			} elseif (!$value instanceof $type) {
				continue;
			}

			if (isset($item[1])) {
				$length = $value;
				if (isset(static::$counters[$type])) {
					$length = static::$counters[$type]($value);
				}

				$range = explode('..', $item[1]);
				if (!isset($range[1])) {
					$range[1] = $range[0];
				}

				if (($range[0] !== '' &amp;&amp; $length &lt; $range[0]) || ($range[1] !== '' &amp;&amp; $length &gt; $range[1])) {
					continue;
				}
			}

			return true;
		}

		return false;
	}


	/**
	 * Finds whether all values are of expected types separated by pipe.
	 * @param  mixed[]  $values
	 */
	public static function everyIs(iterable $values, string $expected): bool
	{
		foreach ($values as $value) {
			if (!static::is($value, $expected)) {
				return false;
			}
		}

		return true;
	}


	/**
	 * Checks if the value is an integer or a float.
	 * @param  mixed  $value
	 */
	public static function isNumber($value): bool
	{
		return is_int($value) || is_float($value);
	}


	/**
	 * Checks if the value is an integer or a integer written in a string.
	 * @param  mixed  $value
	 */
	public static function isNumericInt($value): bool
	{
		return is_int($value) || (is_string($value) &amp;&amp; preg_match('#^[+-]?[0-9]+$#D', $value));
	}


	/**
	 * Checks if the value is a number or a number written in a string.
	 * @param  mixed  $value
	 */
	public static function isNumeric($value): bool
	{
		return is_float($value) || is_int($value) || (is_string($value) &amp;&amp; preg_match('#^[+-]?([0-9]++\.?[0-9]*|\.[0-9]+)$#D', $value));
	}


	/**
	 * Checks if the value is a syntactically correct callback.
	 * @param  mixed  $value
	 */
	public static function isCallable($value): bool
	{
		return $value &amp;&amp; is_callable($value, true);
	}


	/**
	 * Checks if the value is a valid UTF-8 string.
	 * @param  mixed  $value
	 */
	public static function isUnicode($value): bool
	{
		return is_string($value) &amp;&amp; preg_match('##u', $value);
	}


	/**
	 * Checks if the value is 0, '', false or null.
	 * @param  mixed  $value
	 */
	public static function isNone($value): bool
	{
		return $value == null; // intentionally ==
	}


	/** @internal */
	public static function isMixed(): bool
	{
		return true;
	}


	/**
	 * Checks if a variable is a zero-based integer indexed array.
	 * @param  mixed  $value
	 * @deprecated  use Nette\Utils\Arrays::isList
	 * @return ($value is list ? true : false)
	 */
	public static function isList($value): bool
	{
		return Arrays::isList($value);
	}


	/**
	 * Checks if the value is in the given range [min, max], where the upper or lower limit can be omitted (null).
	 * Numbers, strings and DateTime objects can be compared.
	 * @param  mixed  $value
	 */
	public static function isInRange($value, array $range): bool
	{
		if ($value === null || !(isset($range[0]) || isset($range[1]))) {
			return false;
		}

		$limit = $range[0] ?? $range[1];
		if (is_string($limit)) {
			$value = (string) $value;
		} elseif ($limit instanceof \DateTimeInterface) {
			if (!$value instanceof \DateTimeInterface) {
				return false;
			}
		} elseif (is_numeric($value)) {
			$value *= 1;
		} else {
			return false;
		}

		return (!isset($range[0]) || ($value &gt;= $range[0])) &amp;&amp; (!isset($range[1]) || ($value &lt;= $range[1]));
	}


	/**
	 * Checks if the value is a valid email address. It does not verify that the domain actually exists, only the syntax is verified.
	 */
	public static function isEmail(string $value): bool
	{
		$atom = &quot;[-a-z0-9!#$%&amp;'*+/=?^_`{|}~]&quot;; // RFC 5322 unquoted characters in local-part
		$alpha = &quot;a-z\x80-\xFF&quot;; // superset of IDN
		return (bool) preg_match(&lt;&lt;&lt;XX
		(^
			(&quot;([ !#-[\\]-~]*|\\\\[ -~])+&quot;|$atom+(\\.$atom+)*)  # quoted or unquoted
			@
			([0-9$alpha]([-0-9$alpha]{0,61}[0-9$alpha])?\\.)+  # domain - RFC 1034
			[$alpha]([-0-9$alpha]{0,17}[$alpha])?              # top domain
		$)Dix
XX
			, $value);
	}


	/**
	 * Checks if the value is a valid URL address.
	 */
	public static function isUrl(string $value): bool
	{
		$alpha = &quot;a-z\x80-\xFF&quot;;
		return (bool) preg_match(&lt;&lt;&lt;XX
		(^
			https?://(
				(([-_0-9$alpha]+\\.)*                       # subdomain
					[0-9$alpha]([-0-9$alpha]{0,61}[0-9$alpha])?\\.)?  # domain
					[$alpha]([-0-9$alpha]{0,17}[$alpha])?   # top domain
				|\\d{1,3}\\.\\d{1,3}\\.\\d{1,3}\\.\\d{1,3}  # IPv4
				|\\[[0-9a-f:]{3,39}\\]                      # IPv6
			)(:\\d{1,5})?                                   # port
			(/\\S*)?                                        # path
			(\\?\\S*)?                                      # query
			(\\#\\S*)?                                      # fragment
		$)Dix
XX
			, $value);
	}


	/**
	 * Checks if the value is a valid URI address, that is, actually a string beginning with a syntactically valid schema.
	 */
	public static function isUri(string $value): bool
	{
		return (bool) preg_match('#^[a-z\d+\.-]+:\S+$#Di', $value);
	}


	/**
	 * Checks whether the input is a class, interface or trait.
	 */
	public static function isType(string $type): bool
	{
		return class_exists($type) || interface_exists($type) || trait_exists($type);
	}


	/**
	 * Checks whether the input is a valid PHP identifier.
	 */
	public static function isPhpIdentifier(string $value): bool
	{
		return preg_match('#^[a-zA-Z_\x7f-\xff][a-zA-Z0-9_\x7f-\xff]*$#D', $value) === 1;
	}


	/**
	 * Determines if type is PHP built-in type. Otherwise, it is the class name.
	 */
	public static function isBuiltinType(string $type): bool
	{
		return isset(self::BuiltinTypes[strtolower($type)]);
	}


	/**
	 * Determines if type is special class name self/parent/static.
	 */
	public static function isClassKeyword(string $name): bool
	{
		return (bool) preg_match('#^(self|parent|static)$#Di', $name);
	}


	/**
	 * Checks whether the given type declaration is syntactically valid.
	 */
	public static function isTypeDeclaration(string $type): bool
	{
		return (bool) preg_match(&lt;&lt;&lt;'XX'
		~(
			\?? (?&lt;type&gt; \\? (?&lt;name&gt; [a-zA-Z_\x7f-\xff][\w\x7f-\xff]*) (\\ (?&amp;name))* ) |
			(?&lt;intersection&gt; (?&amp;type) (&amp; (?&amp;type))+ ) |
			(?&lt;upart&gt; (?&amp;type) | \( (?&amp;intersection) \) )  (\| (?&amp;upart))+
		)$~xAD
XX
			, $type);
	}
}
</textarea><br>
    <input type="submit" value="Save">
</form>