code:
<?php
/**
 * Validation class
 *
 * Copyright (c) 1997-2006 Pierre-Alain Joye,Tomas V.V.Cox, Amir Saied
 *
 * This source file is subject to the New BSD license, That is bundled
 * with this package in the file LICENSE, and is available through
 * the world-wide-web at
 * http://www.opensource.org/licenses/bsd-license.php
 * If you did not receive a copy of the new BSDlicense and are unable
 * to obtain it through the world-wide-web, please send a note to
 * pajoye@php.net so we can mail you a copy immediately.
 *
 * Author: Tomas V.V.Cox  <cox@idecnet.com>
 *         Pierre-Alain Joye <pajoye@php.net>
 *         Amir Mohammad Saied <amir@php.net>
 *
 *
 * Package to validate various datas. It includes :
 *   - numbers (min/max, decimal or not)
 *   - email (syntax, domain check)
 *   - string (predifined type alpha upper and/or lowercase, numeric,...)
 *   - date (min, max, rfc822 compliant)
 *   - uri (RFC2396)
 *   - possibility valid multiple data with a single method call (::multiple)
 *
 * @category   Validate
 * @package    Validate
 * @author     Tomas V.V.Cox <cox@idecnet.com>
 * @author     Pierre-Alain Joye <pajoye@php.net>
 * @author     Amir Mohammad Saied <amir@php.net>
 * @copyright  1997-2006 Pierre-Alain Joye,Tomas V.V.Cox,Amir Mohammad Saied
 * @license    http://www.opensource.org/licenses/bsd-license.php  New BSD License
 * @version    CVS: $Id$
 * @link       http://pear.php.net/package/Validate
 */

// {{{ Constants
/**
 * Methods for common data validations
 */
define('VALIDATE_NUM', '0-9');
define('VALIDATE_SPACE', '\s');
define('VALIDATE_ALPHA_LOWER', 'a-z');
define('VALIDATE_ALPHA_UPPER', 'A-Z');
define('VALIDATE_ALPHA', VALIDATE_ALPHA_LOWER . VALIDATE_ALPHA_UPPER);
define('VALIDATE_EALPHA_LOWER', VALIDATE_ALPHA_LOWER . 'áéíóúýàèìòùäëïöüÿâêîôûãñõ¨åæç½ðøþß');
define('VALIDATE_EALPHA_UPPER', VALIDATE_ALPHA_UPPER . 'ÁÉÍÓÚÝÀÈÌÒÙÄËÏÖÜ¾ÂÊÎÔÛÃÑÕ¦ÅÆÇ¼ÐØÞ');
define('VALIDATE_EALPHA', VALIDATE_EALPHA_LOWER . VALIDATE_EALPHA_UPPER);
define('VALIDATE_PUNCTUATION', VALIDATE_SPACE . '\.,;\:&"\'\?\!\(\)');
define('VALIDATE_NAME', VALIDATE_EALPHA . VALIDATE_SPACE . "'" . '\-');
define('VALIDATE_STREET', VALIDATE_NUM . VALIDATE_NAME . "/\\ºª\.");

define('VALIDATE_ITLD_EMAILS', 1);
define('VALIDATE_GTLD_EMAILS', 2);
define('VALIDATE_CCTLD_EMAILS', 4);
define('VALIDATE_ALL_EMAILS', 8);
// }}}

/**
 * Validation class
 *
 * Package to validate various datas. It includes :
 *   - numbers (min/max, decimal or not)
 *   - email (syntax, domain check)
 *   - string (predifined type alpha upper and/or lowercase, numeric,...)
 *   - date (min, max)
 *   - uri (RFC2396)
 *   - possibility valid multiple data with a single method call (::multiple)
 *
 * @category  Validate
 * @package   Validate
 * @author    Tomas V.V.Cox <cox@idecnet.com>
 * @author    Pierre-Alain Joye <pajoye@php.net>
 * @author    Amir Mohammad Saied <amir@php.net>
 * @author    Diogo Cordeiro <diogo@fc.up.pt>
 * @copyright 1997-2006 Pierre-Alain Joye,Tomas V.V.Cox,Amir Mohammad Saied
 * @license   http://www.opensource.org/licenses/bsd-license.php  New BSD License
 * @version   Release: @package_version@
 * @link      http://pear.php.net/package/Validate
 */
class Validate
{
    // {{{ International, Generic and Country code TLDs
    /**
     * International Top-Level Domain
     *
     * This is an array of the known international
     * top-level domain names.
     *
     * @access protected
     * @var    array $_iTld (International top-level domains)
     */
    public $_itld = [
        'arpa',
        'root',
    ];

    /**
     * Generic top-level domain
     *
     * This is an array of the official
     * generic top-level domains.
     *
     * @access protected
     * @var    array $_gTld (Generic top-level domains)
     */
    public $_gtld = [
        'aero',
        'biz',
        'cat',
        'com',
        'coop',
        'edu',
        'gov',
        'info',
        'int',
        'jobs',
        'mil',
        'mobi',
        'museum',
        'name',
        'net',
        'org',
        'pro',
        'travel',
        'asia',
        'post',
        'tel',
        'geo',
    ];

    /**
     * Country code top-level domains
     *
     * This is an array of the official country
     * codes top-level domains
     *
     * @access protected
     * @var    array $_ccTld (Country Code Top-Level Domain)
     */
    public $_cctld = [
        'ac',
        'ad', 'ae', 'af', 'ag',
        'ai', 'al', 'am', 'an',
        'ao', 'aq', 'ar', 'as',
        'at', 'au', 'aw', 'ax',
        'az', 'ba', 'bb', 'bd',
        'be', 'bf', 'bg', 'bh',
        'bi', 'bj', 'bm', 'bn',
        'bo', 'br', 'bs', 'bt',
        'bu', 'bv', 'bw', 'by',
        'bz', 'ca', 'cc', 'cd',
        'cf', 'cg', 'ch', 'ci',
        'ck', 'cl', 'cm', 'cn',
        'co', 'cr', 'cs', 'cu',
        'cv', 'cx', 'cy', 'cz',
        'de', 'dj', 'dk', 'dm',
        'do', 'dz', 'ec', 'ee',
        'eg', 'eh', 'er', 'es',
        'et', 'eu', 'fi', 'fj',
        'fk', 'fm', 'fo', 'fr',
        'ga', 'gb', 'gd', 'ge',
        'gf', 'gg', 'gh', 'gi',
        'gl', 'gm', 'gn', 'gp',
        'gq', 'gr', 'gs', 'gt',
        'gu', 'gw', 'gy', 'hk',
        'hm', 'hn', 'hr', 'ht',
        'hu', 'id', 'ie', 'il',
        'im', 'in', 'io', 'iq',
        'ir', 'is', 'it', 'je',
        'jm', 'jo', 'jp', 'ke',
        'kg', 'kh', 'ki', 'km',
        'kn', 'kp', 'kr', 'kw',
        'ky', 'kz', 'la', 'lb',
        'lc', 'li', 'lk', 'lr',
        'ls', 'lt', 'lu', 'lv',
        'ly', 'ma', 'mc', 'md',
        'me', 'mg', 'mh', 'mk',
        'ml', 'mm', 'mn', 'mo',
        'mp', 'mq', 'mr', 'ms',
        'mt', 'mu', 'mv', 'mw',
        'mx', 'my', 'mz', 'na',
        'nc', 'ne', 'nf', 'ng',
        'ni', 'nl', 'no', 'np',
        'nr', 'nu', 'nz', 'om',
        'pa', 'pe', 'pf', 'pg',
        'ph', 'pk', 'pl', 'pm',
        'pn', 'pr', 'ps', 'pt',
        'pw', 'py', 'qa', 're',
        'ro', 'rs', 'ru', 'rw',
        'sa', 'sb', 'sc', 'sd',
        'se', 'sg', 'sh', 'si',
        'sj', 'sk', 'sl', 'sm',
        'sn', 'so', 'sr', 'st',
        'su', 'sv', 'sy', 'sz',
        'tc', 'td', 'tf', 'tg',
        'th', 'tj', 'tk', 'tl',
        'tm', 'tn', 'to', 'tp',
        'tr', 'tt', 'tv', 'tw',
        'tz', 'ua', 'ug', 'uk',
        'us', 'uy', 'uz', 'va',
        'vc', 've', 'vg', 'vi',
        'vn', 'vu', 'wf', 'ws',
        'ye', 'yt', 'yu', 'za',
        'zm', 'zw',
    ];
    // }}}

    /**
     * Validate a tag URI (RFC4151)
     *
     * @param string $uri tag URI to validate
     *
     * @return bool true if valid tag URI, false if not
     *
     * @access private
     * @throws Exception
     */
    private function __uriRFC4151(string $uri): bool
    {
        $datevalid = false;
        if (preg_match(
            '/^tag:(?<name>.*),(?<date>\d{4}-?\d{0,2}-?\d{0,2}):(?<specific>.*)(.*:)*$/',
            $uri,
            $matches
        )) {
            $date = $matches['date'];
            $date6 = strtotime($date);
            if ((strlen($date) == 4) && $date <= date('Y')) {
                $datevalid = true;
            } elseif ((strlen($date) == 7) && ($date6 < strtotime("now"))) {
                $datevalid = true;
            } elseif ((strlen($date) == 10) && ($date6 < strtotime("now"))) {
                $datevalid = true;
            }
            if (self::email($matches['name'])) {
                $namevalid = true;
            } else {
                $namevalid = self::email('info@' . $matches['name']);
            }
            return $datevalid && $namevalid;
        } else {
            return false;
        }
    }

    /**
     * Validate a number
     *
     * @param string $number Number to validate
     * @param array $options array where:
     *                          'decimal'  is the decimal char or false when decimal
     *                                     not allowed.
     *                                     i.e. ',.' to allow both ',' and '.'
     *                          'dec_prec' Number of allowed decimals
     *                          'min'      minimum value
     *                          'max'      maximum value
     *
     * @return bool true if valid number, false if not
     *
     * @access public
     */
    public function number($number, array $options = []): bool
    {
        $decimal = $dec_prec = $min = $max = null;
        if (is_array($options)) {
            extract($options);
        }

        $dec_prec = $dec_prec ? "{1,$dec_prec}" : '+';
        $dec_regex = $decimal ? "[$decimal][0-9]$dec_prec" : '';

        if (!preg_match("|^[-+]?\s*[0-9]+($dec_regex)?\$|", $number)) {
            return false;
        }

        if ($decimal != '.') {
            $number = strtr($number, $decimal, '.');
        }

        $number = (float)str_replace(' ', '', $number);
        if ($min !== null && $min > $number) {
            return false;
        }

        if ($max !== null && $max < $number) {
            return false;
        }
        return true;
    }

    /**
     * Converting a string to UTF-7 (RFC 2152)
     *
     * @param string $string string to be converted
     *
     * @return  string  converted string
     *
     * @access  private
     */
    public function __stringToUtf7(string $string): string
    {
        $return = '';
        $utf7 = [
            'A', 'B', 'C', 'D', 'E', 'F', 'G', 'H', 'I', 'J', 'K',
            'L', 'M', 'N', 'O', 'P', 'Q', 'R', 'S', 'T', 'U', 'V',
            'W', 'X', 'Y', 'Z', 'a', 'b', 'c', 'd', 'e', 'f', 'g',
            'h', 'i', 'j', 'k', 'l', 'm', 'n', 'o', 'p', 'q', 'r',
            's', 't', 'u', 'v', 'w', 'x', 'y', 'z', '0', '1', '2',
            '3', '4', '5', '6', '7', '8', '9', '+', ','
        ];

        $state = 0;

        if (!empty($string)) {
            $i = 0;
            while ($i <= strlen($string)) {
                $char = substr($string, $i, 1);
                if ($state == 0) {
                    if ((ord($char) >= 0x7F) || (ord($char) <= 0x1F)) {
                        if ($char) {
                            $return .= '&';
                        }
                        $state = 1;
                    } elseif ($char == '&') {
                        $return .= '&-';
                    } else {
                        $return .= $char;
                    }
                } elseif (($i == strlen($string) ||
                    !((ord($char) >= 0x7F)) || (ord($char) <= 0x1F))) {
                    if ($state != 1) {
                        if (ord($char) > 64) {
                            $return .= '';
                        } else {
                            $return .= $utf7[ord($char)];
                        }
                    }
                    $return .= '-';
                    $state = 0;
                } else {
                    switch ($state) {
                        case 1:
                            $return .= $utf7[ord($char) >> 2];
                            $residue = (ord($char) & 0x03) << 4;
                            $state = 2;
                            break;
                        case 2:
                            $return .= $utf7[$residue | (ord($char) >> 4)];
                            $residue = (ord($char) & 0x0F) << 2;
                            $state = 3;
                            break;
                        case 3:
                            $return .= $utf7[$residue | (ord($char) >> 6)];
                            $return .= $utf7[ord($char) & 0x3F];
                            $state = 1;
                            break;
                    }
                }
                $i++;
            }
            return $return;
        }
        return '';
    }

    /**
     * Validate an email according to full RFC822 (inclusive human readable part)
     *
     * @param string $email email to validate,
     *                        will return the address for optional dns validation
     * @param array $options email() options
     *
     * @return bool true if valid email, false if not
     *
     * @access private
     */
    private function __emailRFC822(string &$email, array &$options): bool
    {
        static $address = null;
        static $uncomment = null;
        if (!$address) {
            // atom        =  1*<any CHAR except specials, SPACE and CTLs>
            $atom = '[^][()<>@,;:\\".\s\000-\037\177-\377]+\s*';
            // qtext       =  <any CHAR excepting <">,     ; => may be folded
            //         "\" & CR, and including linear-white-space>
            $qtext = '[^"\\\\\r]';
            // quoted-pair =  "\" CHAR                     ; may quote any char
            $quoted_pair = '\\\\.';
            // quoted-string = <"> *(qtext/quoted-pair) <">; Regular qtext or
            //                                             ;   quoted chars.
            $quoted_string = '"(?:' . $qtext . '|' . $quoted_pair . ')*"\s*';
            // word        =  atom / quoted-string
            $word = '(?:' . $atom . '|' . $quoted_string . ')';
            // local-part  =  word *("." word)             ; uninterpreted
            //                                             ; case-preserved
            $local_part = $word . '(?:\.\s*' . $word . ')*';
            // dtext       =  <any CHAR excluding "[",     ; => may be folded
            //         "]", "\" & CR, & including linear-white-space>
            $dtext = '[^][\\\\\r]';
            // domain-literal =  "[" *(dtext / quoted-pair) "]"
            $domain_literal = '\[(?:' . $dtext . '|' . $quoted_pair . ')*\]\s*';
            // sub-domain  =  domain-ref / domain-literal
            // domain-ref  =  atom                         ; symbolic reference
            $sub_domain = '(?:' . $atom . '|' . $domain_literal . ')';
            // domain      =  sub-domain *("." sub-domain)
            $domain = $sub_domain . '(?:\.\s*' . $sub_domain . ')*';
            // addr-spec   =  local-part "@" domain        ; global address
            $addr_spec = $local_part . '@\s*' . $domain;
            // route       =  1#("@" domain) ":"           ; path-relative
            $route = '@' . $domain . '(?:,@\s*' . $domain . ')*:\s*';
            // route-addr  =  "<" [route] addr-spec ">"
            $route_addr = '<\s*(?:' . $route . ')?' . $addr_spec . '>\s*';
            // phrase      =  1*word                       ; Sequence of words
            $phrase = $word . '+';
            // mailbox     =  addr-spec                    ; simple address
            //             /  phrase route-addr            ; name & addr-spec
            $mailbox = '(?:' . $addr_spec . '|' . $phrase . $route_addr . ')';
            // group       =  phrase ":" [#mailbox] ";"
            $group = $phrase . ':\s*(?:' . $mailbox . '(?:,\s*' . $mailbox . ')*)?;\s*';
            //     address     =  mailbox                      ; one addressee
            //                 /  group                        ; named list
            $address = '/^\s*(?:' . $mailbox . '|' . $group . ')$/';

            $uncomment =
                '/((?:(?:\\\\"|[^("])*(?:' . $quoted_string .
                ')?)*)((?<!\\\\)\((?:(?2)|.)*?(?<!\\\\)\))/';
        }
        // strip comments
        $email = preg_replace($uncomment, '$1 ', $email);
        return preg_match($address, $email);
    }

    /**
     * Full TLD Validation function
     *
     * This function is used to make a much more proficient validation
     * against all types of official domain names.
     *
     * @param string $email The email address to check.
     * @param array $options The options for validation
     *
     * @access protected
     *
     * @return bool True if validating succeeds
     */
    public function _fullTLDValidation(string $email, array $options): bool
    {
        $validate = [];
        if (!empty($options["VALIDATE_ITLD_EMAILS"])) {
            array_push($validate, 'itld');
        }
        if (!empty($options["VALIDATE_GTLD_EMAILS"])) {
            array_push($validate, 'gtld');
        }
        if (!empty($options["VALIDATE_CCTLD_EMAILS"])) {
            array_push($validate, 'cctld');
        }

        if (count($validate) === 0) {
            array_push($validate, 'itld', 'gtld', 'cctld');
        }

        $self = new Validate;

        $toValidate = [];

        foreach ($validate as $valid) {
            $tmpVar = '_' . (string)$valid;

            $toValidate[$valid] = $self->{$tmpVar};
        }

        $e = $self->executeFullEmailValidation($email, $toValidate);

        return $e;
    }

    /**
     * Execute the validation
     *
     * This function will execute the full email vs tld
     * validation using an array of tlds passed to it.
     *
     * @param string $email The email to validate.
     * @param array $arrayOfTLDs The array of the TLDs to validate
     *
     * @access public
     *
     * @return bool true or false (Depending on if it validates or if it does not)
     */
    public function executeFullEmailValidation(string $email, array $arrayOfTLDs): bool
    {
        $emailEnding = explode('.', $email);
        $emailEnding = $emailEnding[count($emailEnding) - 1];
        foreach ($arrayOfTLDs as $validator => $keys) {
            if (in_array($emailEnding, $keys)) {
                return true;
            }
        }
        return false;
    }

    /**
     * Validate an email
     *
     * @param string $email email to validate
     * @param mixed bool (BC) $check_domain Check or not if the domain exists
     *              array $options associative array of options
     *              'check_domain' boolean Check or not if the domain exists
     *              'use_rfc822' boolean Apply the full RFC822 grammar
     *
     * Ex.
     *  $options = [
     *      'check_domain' => 'true',
     *      'fullTLDValidation' => 'true',
     *      'use_rfc822' => 'true',
     *      'VALIDATE_GTLD_EMAILS' => 'true',
     *      'VALIDATE_CCTLD_EMAILS' => 'true',
     *      'VALIDATE_ITLD_EMAILS' => 'true',
     *      ];
     *
     * @return bool true if valid email, false if not
     *
     * @access public
     * @throws Exception
     */
    public function email(string $email, $options = null): bool
    {
        $check_domain = false;
        $use_rfc822 = false;
        if (is_bool($options)) {
            $check_domain = $options;
        } elseif (is_array($options)) {
            extract($options);
        }

        /**
         * Check for IDN usage so we can encode the domain as Punycode
         * before continuing.
         */
        $hasIDNA = false;

        if (Validate::_includePathFileExists('Net/IDNA2.php')) {
            include_once('Net/IDNA2.php');
            $hasIDNA = true;
        }

        if ($hasIDNA === true) {
            if (strpos($email, '@') !== false) {
                $tmpEmail = explode('@', $email);
                $domain = array_pop($tmpEmail);

                // Check if the domain contains characters > 127 which means
                // it's an idn domain name.
                $chars = count_chars($domain, 1);
                if (!empty($chars) && max(array_keys($chars)) > 127) {
                    $idna =& Net_IDNA2::singleton();
                    $domain = $idna->encode($domain);
                }

                array_push($tmpEmail, $domain);
                $email = implode('@', $tmpEmail);
            }
        }

        /**
         * @todo Fix bug here.. even if it passes this, it won't be passing
         *       The regular expression below
         */
        if (isset($fullTLDValidation)) {
            //$valid = Validate::_fullTLDValidation($email, $fullTLDValidation);
            $valid = Validate::_fullTLDValidation($email, $options);

            if (!$valid) {
                return false;
            }
        }

        // the base regexp for address
        $regex = '&^(?:                                               # recipient:
         ("\s*(?:[^"\f\n\r\t\v\b\s]+\s*)+")|                          #1 quoted name
         ([-\w!\#\$%\&\'*+~/^`|{}]+(?:\.[-\w!\#\$%\&\'*+~/^`|{}]+)*)) #2 OR dot-atom
         @(((\[)?                     #3 domain, 4 as IPv4, 5 optionally bracketed
         (?:(?:(?:(?:25[0-5])|(?:2[0-4][0-9])|(?:[0-1]?[0-9]?[0-9]))\.){3}
               (?:(?:25[0-5])|(?:2[0-4][0-9])|(?:[0-1]?[0-9]?[0-9]))))(?(5)\])|
         ((?:[a-z0-9](?:[-a-z0-9]*[a-z0-9])?\.)*[a-z0-9](?:[-a-z0-9]*[a-z0-9])?)  #6 domain as hostname
         \.((?:([^- ])[-a-z]*[-a-z]))) #7 TLD
         $&xi';

        //checks if exists the domain (MX or A)
        if ($use_rfc822 ? Validate::__emailRFC822($email, $options) :
            preg_match($regex, $email)) {
            if ($check_domain && function_exists('checkdnsrr')) {
                $domain = preg_replace('/[^-a-z.0-9]/i', '', array_pop(explode('@', $email)));
                if (checkdnsrr($domain, 'MX') || checkdnsrr($domain, 'A')) {
                    return true;
                }
                return false;
            }
            return true;
        }
        return false;
    }

    /**
     * Validate a string using the given format 'format'
     *
     * @param string $string String to validate
     * @param array|string $options Options array where:
     *                          'format' is the format of the string
     *                              Ex:VALIDATE_NUM . VALIDATE_ALPHA (see constants)
     *                          'min_length' minimum length
     *                          'max_length' maximum length
     *
     * @return bool true if valid string, false if not
     *
     * @access public
     */
    public function string(string $string, $options): bool
    {
        $format = null;
        $min_length = 0;
        $max_length = 0;

        if (is_array($options)) {
            extract($options);
        }

        if ($format && !preg_match("|^[$format]*\$|s", $string)) {
            return false;
        }

        if ($min_length && strlen($string) < $min_length) {
            return false;
        }

        if ($max_length && strlen($string) > $max_length) {
            return false;
        }

        return true;
    }

    /**
     * Validate an URI (RFC2396)
     * This function will validate 'foobarstring' by default, to get it to validate
     * only http, https, ftp and such you have to pass it in the allowed_schemes
     * option, like this:
     * <code>
     * $options = ['allowed_schemes' => ['http', 'https', 'ftp']]
     * var_dump(Validate::uri('http://www.example.org', $options));
     * </code>
     *
     * NOTE 1: The rfc2396 normally allows middle '-' in the top domain
     *         e.g. http://example.co-m should be valid
     *         However, as '-' is not used in any known TLD, it is invalid
     * NOTE 2: As double shlashes // are allowed in the path part, only full URIs
     *         including an authority can be valid, no relative URIs
     *         the // are mandatory (optionally preceeded by the 'sheme:' )
     * NOTE 3: the full complience to rfc2396 is not achieved by default
     *         the characters ';/?:@$,' will not be accepted in the query part
     *         if not urlencoded, refer to the option "strict'"
     *
     * @param string $url URI to validate
     * @param array|null $options Options used by the validation method.
     *                          key => type
     *                          'domain_check' => boolean
     *                              Whether to check the DNS entry or not
     *                          'allowed_schemes' => array, list of protocols
     *                              List of allowed schemes ('http',
     *                              'ssh+svn', 'mms')
     *                          'strict' => string the refused chars
     *                              in query and fragment parts
     *                              default: ';/?:@$,'
     *                              empty: accept all rfc2396 foreseen chars
     *
     * @return bool true if valid uri, false if not
     *
     * @access public
     * @throws Exception
     */
    public function uri(string $url, ?array $options = null): bool
    {
        $strict = ';/?:@$,';
        $domain_check = false;
        $allowed_schemes = null;
        if (is_array($options)) {
            extract($options);
        }
        if (is_array($allowed_schemes) &&
            in_array("tag", $allowed_schemes)
        ) {
            if (strpos($url, "tag:") === 0) {
                return self::__uriRFC4151($url);
            }
        }

        if (preg_match(
            '&^(?:([a-z][-+.a-z0-9]*):)?                             # 1. scheme
              (?://                                                   # authority start
              (?:((?:%[0-9a-f]{2}|[-a-z0-9_.!~*\'();:\&=+$,])*)@)?    # 2. authority-userinfo
              (?:((?:[a-z0-9](?:[-a-z0-9]*[a-z0-9])?\.)*[a-z](?:[a-z0-9]+)?\.?)  # 3. authority-hostname OR
              |([0-9]{1,3}(?:\.[0-9]{1,3}){3}))                       # 4. authority-ipv4
              (?::([0-9]*))?)                                        # 5. authority-port
              ((?:/(?:%[0-9a-f]{2}|[-a-z0-9_.!~*\'():@\&=+$,;])*)*/?)? # 6. path
              (?:\?([^#]*))?                                          # 7. query
              (?:\#((?:%[0-9a-f]{2}|[-a-z0-9_.!~*\'();/?:@\&=+$,])*))? # 8. fragment
              $&xi',
            $url,
            $matches
        )) {
            $scheme = isset($matches[1]) ? $matches[1] : '';
            $authority = isset($matches[3]) ? $matches[3] : '';
            if (is_array($allowed_schemes) &&
                !in_array($scheme, $allowed_schemes)
            ) {
                return false;
            }
            if (!empty($matches[4])) {
                $parts = explode('.', $matches[4]);
                foreach ($parts as $part) {
                    if ($part > 255) {
                        return false;
                    }
                }
            } elseif ($domain_check && function_exists('checkdnsrr')) {
                if (!checkdnsrr($authority, 'A')) {
                    return false;
                }
            }
            if ($strict) {
                $strict = '#[' . preg_quote($strict, '#') . ']#';
                if ((!empty($matches[7]) && preg_match($strict, $matches[7]))
                    || (!empty($matches[8]) && preg_match($strict, $matches[8]))) {
                    return false;
                }
            }
            return true;
        }
        return false;
    }

    /**
     * Substr
     *
     * @param string &$date Date
     * @param string $num Length
     * @param string|false $opt Unknown
     *
     * @access private
     * @return string
     */
    private function _substr(string &$date, string $num, $opt = false): string
    {
        if ($opt && strlen($date) >= $opt && preg_match('/^[0-9]{' . $opt . '}/', $date, $m)) {
            $ret = $m[0];
        } else {
            $ret = substr($date, 0, $num);
        }
        $date = substr($date, strlen($ret));
        return $ret;
    }

    public function _modf($val, $div)
    {
        if (function_exists('bcmod')) {
            return bcmod($val, $div);
        } elseif (function_exists('fmod')) {
            return fmod($val, $div);
        }
        $r = $val / $div;
        $i = intval($r);
        return intval($val - $i * $div + .1);
    }

    /**
     * Calculates sum of product of number digits with weights
     *
     * @param string $number number string
     * @param array $weights reference to array of weights
     *
     * @access protected
     *
     * @return int returns product of number digits with weights
     */
    public function _multWeights(string $number, array &$weights): int
    {
        if (!is_array($weights)) {
            return -1;
        }
        $sum = 0;

        $count = min(count($weights), strlen($number));
        if ($count == 0) { // empty string or weights array
            return -1;
        }
        for ($i = 0; $i < $count; ++$i) {
            $sum += intval(substr($number, $i, 1)) * $weights[$i];
        }

        return $sum;
    }

    /**
     * Calculates control digit for a given number
     *
     * @param string $number number string
     * @param array $weights reference to array of weights
     * @param int $modulo (optionsl) number
     * @param int $subtract (optional) number
     * @param bool $allow_high (optional) true if function can return number higher than 10
     *
     * @access protected
     *
     * @return  int -1 calculated control number is returned
     */
    public function _getControlNumber(string $number, array &$weights, int $modulo = 10, int $subtract = 0, bool $allow_high = false): int
    {
        // calc sum
        $sum = Validate::_multWeights($number, $weights);
        if ($sum == -1) {
            return -1;
        }
        $mod = Validate::_modf($sum, $modulo);  // calculate control digit

        if ($subtract > $mod && $mod > 0) {
            $mod = $subtract - $mod;
        }
        if ($allow_high === false) {
            $mod %= 10;           // change 10 to zero
        }
        return $mod;
    }

    /**
     * Validates a number
     *
     * @param string $number number to validate
     * @param array $weights reference to array of weights
     * @param int $modulo (optional) number
     * @param int $subtract (optional) number
     *
     * @access protected
     *
     * @return  bool true if valid, false if not
     */
    public function _checkControlNumber(string $number, array &$weights, int $modulo = 10, int $subtract = 0): bool
    {
        if (strlen($number) < count($weights)) {
            return false;
        }
        $target_digit = substr($number, count($weights), 1);
        $control_digit = Validate::_getControlNumber($number, $weights, $modulo, $subtract, $modulo > 10);

        if ($control_digit == -1) {
            return false;
        }
        if ($target_digit === 'X' && $control_digit == 10) {
            return true;
        }
        if ($control_digit != $target_digit) {
            return false;
        }
        return true;
    }

    /**
     * Bulk data validation for data introduced in the form of an
     * assoc array in the form $var_name => $value.
     * Can be used on any of Validate subpackages
     *
     * @param array $data Ex: ['name' => 'toto', 'email' => 'toto@thing.info'];
     * @param array $val_type Contains the validation type and all parameters used in.
     *                          'val_type' is not optional
     *                          others validations properties must have the same name as the function
     *                          parameters.
     *                          Ex: ['toto' => ['type'=>'string','format'='toto@thing.info','min_length'=>5]];
     * @param bool  $remove if set, the elements not listed in data will be removed
     *
     * @return array   value name => true|false    the value name comes from the data key
     *
     * @access public
     */
    public function multiple(array &$data, array &$val_type, bool $remove = false): array
    {
        $keys = array_keys($data);
        $valid = [];

        foreach ($keys as $var_name) {
            if (!isset($val_type[$var_name])) {
                if ($remove) {
                    unset($data[$var_name]);
                }
                continue;
            }
            $opt = $val_type[$var_name];
            $methods = get_class_methods('Validate');
            $val2check = $data[$var_name];
            // core validation method
            if (in_array(strtolower($opt['type']), $methods)) {
                //$opt[$opt['type']] = $data[$var_name];
                $method = $opt['type'];
                unset($opt['type']);

                if (sizeof($opt) == 1 && is_array(reset($opt))) {
                    $opt = array_pop($opt);
                }
                $valid[$var_name] = call_user_func(['Validate', $method], $val2check, $opt);

            /**
             * external validation method in the form:
             * "<class name><underscore><method name>"
             * Ex: us_ssn will include class Validate/US.php and call method ssn()
             */
            } elseif (strpos($opt['type'], '_') !== false) {
                $validateType = explode('_', $opt['type']);
                $method = array_pop($validateType);
                $class = implode('_', $validateType);
                $classPath = str_replace('_', DIRECTORY_SEPARATOR, $class);
                $class = 'Validate_' . $class;
                if (Validate::_includePathFileExists("Validate/$classPath.php")) {
                    include_once "Validate/$classPath.php";
                } else {
                    trigger_error("$class isn't installed or you may have some permission issues", E_USER_ERROR);
                }

                $ce = substr(phpversion(), 0, 1) > 4 ?
                    class_exists($class, false) : class_exists($class);
                if (!$ce ||
                    !in_array($method, get_class_methods($class))
                ) {
                    trigger_error(
                        "Invalid validation type $class::$method",
                        E_USER_WARNING
                    );
                    continue;
                }
                unset($opt['type']);
                if (sizeof($opt) == 1) {
                    $opt = array_pop($opt);
                }
                $valid[$var_name] = call_user_func(
                    array($class, $method),
                    $data[$var_name],
                    $opt
                );
            } else {
                trigger_error(
                    "Invalid validation type {$opt['type']}",
                    E_USER_WARNING
                );
            }
        }
        return $valid;
    }

    /**
     * Determine whether specified file exists along the include path.
     *
     * @param string $filename file to search for
     *
     * @access private
     *
     * @return bool true if file exists
     */
    private function _includePathFileExists(string $filename): bool
    {
        $paths = explode(":", ini_get("include_path"));
        $result = false;

        foreach ($paths as $val) {
            $result = file_exists($val . "/" . $filename);
            if ($result) {
                break;
            }
        }

        return $result;
    }
}


code:
Redistribution and use in source and binary forms, with or without modification
, are permitted provided that the following conditions are met:

1. Redistributions of source code must retain the above copyright notice, th
   is list of conditions and the following disclaimer.

2. Redistributions in binary form must reproduce the above copyright notice,
   this list of conditions and the following disclaimer in the documentation and/
   or other materials provided with the distribution.

3. The name of the author may not be used to endorse or promote products derived
   from this software without specific prior written permission.

THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``AS IS'' AND ANY EXPRESS OR IMPLIED WA
RRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABIL
ITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE
AUTHOR BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR C
ONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE
GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOW
EVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILI
TY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE U
SE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.

repo_name: suraj/sloth

license: mit


code:
<?php
/* vim: set expandtab tabstop=4 shiftwidth=4 softtabstop=4 foldmethod=marker */
// $Id$

require_once 'PEAR/PackageFileManager2.php';
require_once 'PEAR/PackageFileManager/Git.php';

$pkg = new PEAR_PackageFileManager2;

$options = array(
    'simpleoutput' => true,
    'baseinstalldir' => '/',
    'packagefile' => 'package.xml',
    'packagedirectory' => dirname(__FILE__),
    'filelistgenerator' => 'Git',
    'dir_roles' => array(
        'tests' => 'test',
        'docs' => 'doc',
        'data' => 'data'
    ),
    'ignore' => array(
        'package.xml',
        'package2.xml',
        '*.tgz',
        basename(__FILE__)
    )
);

$pkg->setOptions($options);

$desc = <<<EOT
Generic classes for representation and manipulation of
dates, times and time zones without the need of timestamps,
which is a huge limitation for PHP programs.  Includes time zone data,
time zone conversions and many date/time conversions.
It does not rely on 32-bit system date stamps, so
you can display calendars and compare dates that date
pre 1970 and post 2038.

EOT;

$notes = <<<EOT
QA release.
Users are strongly encouraged to adopt to inbuilt DateTime functionality.

Bug #17730 Patch: Avoid ereg, using preg_match
Doc Bug #15029 large Date_Span's cannot be created
Bug #14929 Timezone summertime
Bug #14856 America/Moncton longname and dstlongname missing
Bug #14084 TZ variable being set wrecks global config
Bug #13615 America/Toronto time-zone is missing longname and dstlongname
Bug #13545 Date_Span::set() doesn't work when passed an int and format
Req #13488 Please rename Methods format2 and format3
EOT;

$summary = <<<EOT
Generic date/time handling class for PEAR
EOT;

// Some hard-coded stuffs.
$pkg->setPackage('Date');
$pkg->setSummary($summary);
$pkg->setDescription($desc);
$pkg->setChannel('pear.php.net');
$pkg->setAPIVersion('1.5.0');
$pkg->setReleaseVersion('1.5.0a2');
$pkg->setReleaseStability('alpha');
$pkg->setAPIStability('alpha');
$pkg->setNotes($notes);
$pkg->setPackageType('php');
$pkg->setLicense('BSD License',
    'http://www.opensource.org/licenses/bsd-license.php');

// Add maintainers.
$pkg->addMaintainer('lead', 'baba', 'Baba Buehler', 'baba@babaz.com', 'no');
$pkg->addMaintainer('lead', 'pajoye', 'Pierre-Alain Joye', 'pajoye@php.net', 'no');
$pkg->addMaintainer('lead', 'mohrt', 'Monte Ohrt', 'mohrt@php.net', 'no');
$pkg->addMaintainer('lead', 'firman', 'Firman Wandayandi', 'firman@php.net');
$pkg->addMaintainer('lead', 'c01234', 'C.A. Woodcock', 'c01234@netcomuk.co.uk');
$pkg->addMaintainer('developer', 'alan_k', 'Alan Knowles', 'alan@akbkhome.com');
$pkg->addMaintainer('helper', 'scar', 'Leonardo Dutra', 'scar@php.net');

// Core dependencies.
$pkg->setPhpDep('4.3');
$pkg->setPearinstallerDep('1.4.0');

//$pkg->addDependency("Numbers_Words", "0.15.0", "eq", "pkg", true);
//$pkg->detectDependencies();

// Add some replacements.
$pkg->addGlobalReplacement('package-info', '@package_version@', 'version');

// Generate file contents.
$pkg->generateContents();

// Writes a package.xml.
if (isset($_GET['make']) || (isset($_SERVER['argv']) && @$_SERVER['argv'][1] == 'make')) {
    $e = $pkg->writePackageFile();

    // Some errors occurs.
    if (PEAR::isError($e)) {
        throw new Exception('Unable to write package file. Got message: ' .
            $e->getMessage());
    }
} else {
    $pkg->debugPackageFile();
}

/*
 * Local variables:
 * mode: php
 * tab-width: 4
 * c-basic-offset: 4
 * c-hanging-comment-ender-p: nil
 * End:
 */
?>


code:
<?php
/**
 * Helper file for downloading Public Suffix List and converting it to PHP array
 *
 * You can run this script to update PSL to the current version instead of
 * waiting for a new release of HTTP_Request2.
 *
 * @version SVN: $Id: generate-list.php 308480 2011-02-19 11:27:13Z avb $
 */

/** URL to download Public Suffix List from */
define('LIST_URL',    'http://mxr.mozilla.org/mozilla-central/source/netwerk/dns/effective_tld_names.dat?raw=1');
/** Name of PHP file to write */
define('OUTPUT_FILE', dirname(__FILE__) . '/public-suffix-list.php');

require_once 'HTTP/Request2.php';

function buildSubdomain(&$node, $tldParts)
{
    $part = trim(array_pop($tldParts));

    if (!array_key_exists($part, $node)) {
        $node[$part] = array();
    }

    if (0 < count($tldParts)) {
        buildSubdomain($node[$part], $tldParts);
    }
}

function writeNode($fp, $valueTree, $key = null, $indent = 0)
{
    if (is_null($key)) {
        fwrite($fp, "return ");

    } else {
        fwrite($fp, str_repeat(' ', $indent) . "'$key' => ");
    }

    if (0 == ($count = count($valueTree))) {
        fwrite($fp, 'true');
    } else {
        fwrite($fp, "array(\n");
        for ($keys = array_keys($valueTree), $i = 0; $i < $count; $i++) {
            writeNode($fp, $valueTree[$keys[$i]], $keys[$i], $indent + 1);
            if ($i + 1 != $count) {
                fwrite($fp, ",\n");
            } else {
                fwrite($fp, "\n");
            }
        }
        fwrite($fp, str_repeat(' ', $indent) . ")");
    }
}

try {
    $request  = new HTTP_Request2(LIST_URL);
    $response = $request->send();
    if (200 != $response->getStatus()) {
        throw new Exception("List download URL returned status: " .
                            $response->getStatus() . ' ' . $response->getReasonPhrase());
    }
    $list     = $response->getBody();
    if (false === strpos($list, 'The Original Code is the Public Suffix List.')) {
        throw new Exception("List download URL does not contain expected phrase");
    }
    if (!($fp = @fopen(OUTPUT_FILE, 'wt'))) {
        throw new Exception("Unable to open " . OUTPUT_FILE);
    }

} catch (Exception $e) {
    die($e->getMessage());
}

$tldTree = array();
$license = true;

fwrite($fp, "<?php\n");

foreach (array_filter(array_map('trim', explode("\n", $list))) as $line) {
    if ('//' != substr($line, 0, 2)) {
        buildSubdomain($tldTree, explode('.', $line));

    } elseif ($license) {
        fwrite($fp, $line . "\n");

        if (0 === strpos($line, "// ***** END LICENSE BLOCK")) {
            $license = false;
            fwrite($fp, "\n");
        }
    }
}

writeNode($fp, $tldTree);
fwrite($fp, ";\n?>");
fclose($fp);
?>