Update to drupal 8.0.0-rc1. For more information, see https://www.drupal.org/node/2582663

vendor/egulias/email-validator/src/Egulias/EmailValidator/EmailLexer.php

@@ -0,0 +1,223 @@
+<?php
+
+namespace Egulias\EmailValidator;
+
+use Doctrine\Common\Lexer\AbstractLexer;
+
+class EmailLexer extends AbstractLexer
+{
+    //ASCII values
+    const C_DEL              = 127;
+    const C_NUL              = 0;
+    const S_AT               = 64;
+    const S_BACKSLASH        = 92;
+    const S_DOT              = 46;
+    const S_DQUOTE           = 34;
+    const S_OPENPARENTHESIS  = 49;
+    const S_CLOSEPARENTHESIS = 261;
+    const S_OPENBRACKET      = 262;
+    const S_CLOSEBRACKET     = 263;
+    const S_HYPHEN           = 264;
+    const S_COLON            = 265;
+    const S_DOUBLECOLON      = 266;
+    const S_SP               = 267;
+    const S_HTAB             = 268;
+    const S_CR               = 269;
+    const S_LF               = 270;
+    const S_IPV6TAG          = 271;
+    const S_LOWERTHAN        = 272;
+    const S_GREATERTHAN      = 273;
+    const S_COMMA            = 274;
+    const S_SEMICOLON        = 275;
+    const S_OPENQBRACKET     = 276;
+    const S_CLOSEQBRACKET    = 277;
+    const S_SLASH            = 278;
+    const S_EMPTY            = null;
+    const GENERIC            = 300;
+    const CRLF               = 301;
+    const INVALID            = 302;
+    const ASCII_INVALID_FROM = 127;
+    const ASCII_INVALID_TO   = 199;
+
+    /**
+     * US-ASCII visible characters not valid for atext (@link http://tools.ietf.org/html/rfc5322#section-3.2.3)
+     *
+     * @var array
+     */
+    protected $charValue = array(
+        '('    => self::S_OPENPARENTHESIS,
+        ')'    => self::S_CLOSEPARENTHESIS,
+        '<'    => self::S_LOWERTHAN,
+        '>'    => self::S_GREATERTHAN,
+        '['    => self::S_OPENBRACKET,
+        ']'    => self::S_CLOSEBRACKET,
+        ':'    => self::S_COLON,
+        ';'    => self::S_SEMICOLON,
+        '@'    => self::S_AT,
+        '\\'   => self::S_BACKSLASH,
+        '/'    => self::S_SLASH,
+        ','    => self::S_COMMA,
+        '.'    => self::S_DOT,
+        '"'    => self::S_DQUOTE,
+        '-'    => self::S_HYPHEN,
+        '::'   => self::S_DOUBLECOLON,
+        ' '    => self::S_SP,
+        "\t"   => self::S_HTAB,
+        "\r"   => self::S_CR,
+        "\n"   => self::S_LF,
+        "\r\n" => self::CRLF,
+        'IPv6' => self::S_IPV6TAG,
+        '<'    => self::S_LOWERTHAN,
+        '>'    => self::S_GREATERTHAN,
+        '{'    => self::S_OPENQBRACKET,
+        '}'    => self::S_CLOSEQBRACKET,
+        ''     => self::S_EMPTY,
+        '\0'   => self::C_NUL,
+    );
+
+    protected $hasInvalidTokens = false;
+
+    protected $previous;
+
+    public function reset()
+    {
+        $this->hasInvalidTokens = false;
+        parent::reset();
+    }
+
+    public function hasInvalidTokens()
+    {
+        return $this->hasInvalidTokens;
+    }
+
+    /**
+     * @param $type
+     * @throws \UnexpectedValueException
+     * @return boolean
+     */
+    public function find($type)
+    {
+        $search = clone $this;
+        $search->skipUntil($type);
+
+        if (!$search->lookahead) {
+            throw new \UnexpectedValueException($type . ' not found');
+        }
+        return true;
+    }
+
+    /**
+     * getPrevious
+     *
+     * @return array token
+     */
+    public function getPrevious()
+    {
+        return $this->previous;
+    }
+
+    /**
+     * moveNext
+     *
+     * @return boolean
+     */
+    public function moveNext()
+    {
+        $this->previous = $this->token;
+
+        return parent::moveNext();
+    }
+
+    /**
+     * Lexical catchable patterns.
+     *
+     * @return string[]
+     */
+    protected function getCatchablePatterns()
+    {
+        return array(
+            '[a-zA-Z_]+[46]?', //ASCII and domain literal
+            '[^\x00-\x7F]',  //UTF-8
+            '[0-9]+',
+            '\r\n',
+            '::',
+            '\s+?',
+            '.',
+            );
+    }
+
+    /**
+     * Lexical non-catchable patterns.
+     *
+     * @return string[]
+     */
+    protected function getNonCatchablePatterns()
+    {
+        return array('[\xA0-\xff]+');
+    }
+
+    /**
+     * Retrieve token type. Also processes the token value if necessary.
+     *
+     * @param string $value
+     * @throws \InvalidArgumentException
+     * @return integer
+     */
+    protected function getType(&$value)
+    {
+        if ($this->isNullType($value)) {
+            return self::C_NUL;
+        }
+
+        if ($this->isValid($value)) {
+            return $this->charValue[$value];
+        }
+
+        if ($this->isUTF8Invalid($value)) {
+            $this->hasInvalidTokens = true;
+            return self::INVALID;
+        }
+
+        return  self::GENERIC;
+    }
+
+    protected function isValid($value)
+    {
+        if (isset($this->charValue[$value])) {
+            return true;
+        }
+
+        return false;
+    }
+
+    /**
+     * @param $value
+     * @return bool
+     */
+    protected function isNullType($value)
+    {
+        if ($value === "\0") {
+            return true;
+        }
+
+        return false;
+    }
+
+    /**
+     * @param $value
+     * @return bool
+     */
+    protected function isUTF8Invalid($value)
+    {
+        if (preg_match('/\p{Cc}+/u', $value)) {
+            return true;
+        }
+
+        return false;
+    }
+
+    protected function getModifiers()
+    {
+        return 'iu';
+    }
+}

vendor/egulias/email-validator/src/Egulias/EmailValidator/EmailParser.php

@@ -0,0 +1,100 @@
+<?php
+
+namespace Egulias\EmailValidator;
+
+use Egulias\EmailValidator\Parser\DomainPart;
+use Egulias\EmailValidator\Parser\LocalPart;
+
+/**
+ * EmailParser
+ *
+ * @author Eduardo Gulias Davis <me@egulias.com>
+ */
+class EmailParser
+{
+    const EMAIL_MAX_LENGTH = 254;
+
+    protected $warnings = array();
+    protected $domainPart = '';
+    protected $localPart = '';
+    protected $lexer;
+    protected $localPartParser;
+    protected $domainPartParser;
+
+    public function __construct(EmailLexer $lexer)
+    {
+        $this->lexer = $lexer;
+        $this->localPartParser = new LocalPart($this->lexer);
+        $this->domainPartParser = new DomainPart($this->lexer);
+    }
+
+    /**
+     * @param $str
+     * @return array
+     */
+    public function parse($str)
+    {
+        $this->lexer->setInput($str);
+
+        if (!$this->hasAtToken()) {
+            throw new \InvalidArgumentException('ERR_NOLOCALPART');
+        }
+
+
+        $this->localPartParser->parse($str);
+        $this->domainPartParser->parse($str);
+
+        $this->setParts($str);
+
+        if ($this->lexer->hasInvalidTokens()) {
+            throw new \InvalidArgumentException('ERR_INVALID_ATEXT');
+        }
+
+        return array('local' => $this->localPart, 'domain' => $this->domainPart);
+    }
+
+    public function getWarnings()
+    {
+        $localPartWarnings = $this->localPartParser->getWarnings();
+        $domainPartWarnings = $this->domainPartParser->getWarnings();
+
+        $this->warnings = array_merge($localPartWarnings, $domainPartWarnings);
+        $this->addLongEmailWarning($this->localPart, $this->domainPart);
+
+        return $this->warnings;
+    }
+
+    public function getParsedDomainPart()
+    {
+        return $this->domainPart;
+    }
+
+    protected function setParts($email)
+    {
+        $parts = explode('@', $email);
+        $this->domainPart = $this->domainPartParser->getDomainPart();
+        $this->localPart = $parts[0];
+    }
+
+    protected function hasAtToken()
+    {
+        $this->lexer->moveNext();
+        $this->lexer->moveNext();
+        if ($this->lexer->token['type'] === EmailLexer::S_AT) {
+            return false;
+        }
+
+        return true;
+    }
+
+    /**
+     * @param string $localPart
+     * @param string $parsedDomainPart
+     */
+    protected function addLongEmailWarning($localPart, $parsedDomainPart)
+    {
+        if (strlen($localPart . '@' . $parsedDomainPart) > self::EMAIL_MAX_LENGTH) {
+            $this->warnings[] = EmailValidator::RFC5322_TOOLONG;
+        }
+    }
+}

vendor/egulias/email-validator/src/Egulias/EmailValidator/EmailValidator.php

@@ -0,0 +1,169 @@
+<?php
+
+namespace Egulias\EmailValidator;
+
+/**
+ * EmailValidator
+ *
+ * @author Eduardo Gulias Davis <me@egulias.com>
+ */
+class EmailValidator
+{
+    const ERR_CONSECUTIVEATS     = 128;
+    const ERR_EXPECTING_DTEXT    = 129;
+    const ERR_NOLOCALPART        = 130;
+    const ERR_NODOMAIN           = 131;
+    const ERR_CONSECUTIVEDOTS    = 132;
+    const ERR_ATEXT_AFTER_CFWS   = 133;
+    const ERR_ATEXT_AFTER_QS     = 134;
+    const ERR_ATEXT_AFTER_DOMLIT = 135;
+    const ERR_EXPECTING_QPAIR    = 136;
+    const ERR_EXPECTING_ATEXT    = 137;
+    const ERR_EXPECTING_QTEXT    = 138;
+    const ERR_EXPECTING_CTEXT    = 139;
+    const ERR_BACKSLASHEND       = 140;
+    const ERR_DOT_START          = 141;
+    const ERR_DOT_END            = 142;
+    const ERR_DOMAINHYPHENSTART  = 143;
+    const ERR_DOMAINHYPHENEND    = 144;
+    const ERR_UNCLOSEDQUOTEDSTR  = 145;
+    const ERR_UNCLOSEDCOMMENT    = 146;
+    const ERR_UNCLOSEDDOMLIT     = 147;
+    const ERR_FWS_CRLF_X2        = 148;
+    const ERR_FWS_CRLF_END       = 149;
+    const ERR_CR_NO_LF           = 150;
+    const ERR_DEPREC_REACHED     = 151;
+    const RFC5321_TLD             = 9;
+    const RFC5321_TLDNUMERIC      = 10;
+    const RFC5321_QUOTEDSTRING    = 11;
+    const RFC5321_ADDRESSLITERAL  = 12;
+    const RFC5321_IPV6DEPRECATED  = 13;
+    const CFWS_COMMENT            = 17;
+    const CFWS_FWS                = 18;
+    const DEPREC_LOCALPART        = 33;
+    const DEPREC_FWS              = 34;
+    const DEPREC_QTEXT            = 35;
+    const DEPREC_QP               = 36;
+    const DEPREC_COMMENT          = 37;
+    const DEPREC_CTEXT            = 38;
+    const DEPREC_CFWS_NEAR_AT     = 49;
+    const RFC5322_LOCAL_TOOLONG   = 64;
+    const RFC5322_LABEL_TOOLONG   = 63;
+    const RFC5322_DOMAIN          = 65;
+    const RFC5322_TOOLONG         = 66;
+    const RFC5322_DOMAIN_TOOLONG  = 255;
+    const RFC5322_DOMAINLITERAL   = 70;
+    const RFC5322_DOMLIT_OBSDTEXT = 71;
+    const RFC5322_IPV6_GRPCOUNT   = 72;
+    const RFC5322_IPV6_2X2XCOLON  = 73;
+    const RFC5322_IPV6_BADCHAR    = 74;
+    const RFC5322_IPV6_MAXGRPS    = 75;
+    const RFC5322_IPV6_COLONSTRT  = 76;
+    const RFC5322_IPV6_COLONEND   = 77;
+    const DNSWARN_NO_MX_RECORD    = 5;
+    const DNSWARN_NO_RECORD       = 6;
+
+    protected $parser;
+    protected $warnings = array();
+    protected $error;
+    protected $threshold = 255;
+
+    public function __construct()
+    {
+        $this->parser = new EmailParser(new EmailLexer());
+    }
+
+    public function isValid($email, $checkDNS = false, $strict = false)
+    {
+        try {
+            $this->parser->parse((string)$email);
+            $this->warnings = $this->parser->getWarnings();
+        } catch (\Exception $e) {
+            $rClass = new \ReflectionClass($this);
+            $this->error = $rClass->getConstant($e->getMessage());
+            return false;
+        }
+
+        $dns = true;
+        if ($checkDNS) {
+            $dns = $this->checkDNS();
+        }
+
+        if ($this->hasWarnings() && ((int) max($this->warnings) > $this->threshold)) {
+            $this->error = self::ERR_DEPREC_REACHED;
+
+            return false;
+        }
+
+        return !$strict || (!$this->hasWarnings() && $dns);
+    }
+
+    /**
+     * @return boolean
+     */
+    public function hasWarnings()
+    {
+        return !empty($this->warnings);
+    }
+
+    /**
+     * @return array
+     */
+    public function getWarnings()
+    {
+        return $this->warnings;
+    }
+
+    /**
+     * @return string
+     */
+    public function getError()
+    {
+        return $this->error;
+    }
+
+    /**
+     * @param int $threshold
+     *
+     * @return EmailValidator
+     */
+    public function setThreshold($threshold)
+    {
+        $this->threshold = (int) $threshold;
+
+        return $this;
+    }
+
+    /**
+     * @return int
+     */
+    public function getThreshold()
+    {
+        return $this->threshold;
+    }
+
+    protected function checkDNS()
+    {
+        $checked = true;
+
+        $result = checkdnsrr(trim($this->parser->getParsedDomainPart()), 'MX');
+
+        if (!$result) {
+            $this->warnings[] = self::DNSWARN_NO_RECORD;
+            $checked = false;
+            $this->addTLDWarnings();
+        }
+
+        return $checked;
+    }
+
+    protected function addTLDWarnings()
+    {
+        if (!in_array(self::DNSWARN_NO_RECORD, $this->warnings) &&
+            !in_array(self::DNSWARN_NO_MX_RECORD, $this->warnings) &&
+            in_array(self::RFC5322_DOMAINLITERAL, $this->warnings)
+        ) {
+            $this->warnings[] = self::RFC5321_TLD;
+        }
+    }
+}

vendor/egulias/email-validator/src/Egulias/EmailValidator/Parser/DomainPart.php

@@ -0,0 +1,317 @@
+<?php
+
+
+namespace Egulias\EmailValidator\Parser;
+
+use Egulias\EmailValidator\EmailLexer;
+use Egulias\EmailValidator\Parser\Parser;
+use Egulias\EmailValidator\EmailValidator;
+
+class DomainPart extends Parser
+{
+    const DOMAIN_MAX_LENGTH = 254;
+    protected $domainPart = '';
+
+    public function parse($domainPart)
+    {
+        $this->lexer->moveNext();
+
+        if ($this->lexer->token['type'] === EmailLexer::S_DOT) {
+            throw new \InvalidArgumentException('ERR_DOT_START');
+        }
+
+        if ($this->lexer->token['type'] === EmailLexer::S_EMPTY) {
+            throw new \InvalidArgumentException('ERR_NODOMAIN');
+        }
+        if ($this->lexer->token['type'] === EmailLexer::S_HYPHEN) {
+            throw new \InvalidArgumentException('ERR_DOMAINHYPHENEND');
+        }
+
+        if ($this->lexer->token['type'] === EmailLexer::S_OPENPARENTHESIS) {
+            $this->warnings[] = EmailValidator::DEPREC_COMMENT;
+            $this->parseDomainComments();
+        }
+
+        $domain = $this->doParseDomainPart();
+
+        $prev = $this->lexer->getPrevious();
+        $length = strlen($domain);
+
+        if ($prev['type'] === EmailLexer::S_DOT) {
+            throw new \InvalidArgumentException('ERR_DOT_END');
+        }
+        if ($prev['type'] === EmailLexer::S_HYPHEN) {
+            throw new \InvalidArgumentException('ERR_DOMAINHYPHENEND');
+        }
+        if ($length > self::DOMAIN_MAX_LENGTH) {
+            $this->warnings[] = EmailValidator::RFC5322_DOMAIN_TOOLONG;
+        }
+        if ($prev['type'] === EmailLexer::S_CR) {
+            throw new \InvalidArgumentException('ERR_FWS_CRLF_END');
+        }
+        $this->domainPart = $domain;
+    }
+
+    public function getDomainPart()
+    {
+        return $this->domainPart;
+    }
+
+    public function checkIPV6Tag($addressLiteral, $maxGroups = 8)
+    {
+        $prev = $this->lexer->getPrevious();
+        if ($prev['type'] === EmailLexer::S_COLON) {
+            $this->warnings[] = EmailValidator::RFC5322_IPV6_COLONEND;
+        }
+
+        $IPv6       = substr($addressLiteral, 5);
+        //Daniel Marschall's new IPv6 testing strategy
+        $matchesIP  = explode(':', $IPv6);
+        $groupCount = count($matchesIP);
+        $colons     = strpos($IPv6, '::');
+
+        if (count(preg_grep('/^[0-9A-Fa-f]{0,4}$/', $matchesIP, PREG_GREP_INVERT)) !== 0) {
+            $this->warnings[] = EmailValidator::RFC5322_IPV6_BADCHAR;
+        }
+
+        if ($colons === false) {
+            // We need exactly the right number of groups
+            if ($groupCount !== $maxGroups) {
+                $this->warnings[] = EmailValidator::RFC5322_IPV6_GRPCOUNT;
+            }
+            return;
+        }
+
+        if ($colons !== strrpos($IPv6, '::')) {
+            $this->warnings[] = EmailValidator::RFC5322_IPV6_2X2XCOLON;
+            return;
+        }
+
+        if ($colons === 0 || $colons === (strlen($IPv6) - 2)) {
+            // RFC 4291 allows :: at the start or end of an address
+            //with 7 other groups in addition
+            ++$maxGroups;
+        }
+
+        if ($groupCount > $maxGroups) {
+            $this->warnings[] = EmailValidator::RFC5322_IPV6_MAXGRPS;
+        } elseif ($groupCount === $maxGroups) {
+            $this->warnings[] = EmailValidator::RFC5321_IPV6DEPRECATED;
+        }
+    }
+
+    protected function doParseDomainPart()
+    {
+        $domain = '';
+        do {
+
+            $prev = $this->lexer->getPrevious();
+
+            if ($this->lexer->token['type'] === EmailLexer::S_SLASH) {
+                throw new \InvalidArgumentException('ERR_DOMAIN_CHAR_NOT_ALLOWED');
+            }
+
+            if ($this->lexer->token['type'] === EmailLexer::S_OPENPARENTHESIS) {
+                $this->parseComments();
+                $this->lexer->moveNext();
+            }
+
+            $this->checkConsecutiveDots();
+            $this->checkDomainPartExceptions($prev);
+
+            if ($this->hasBrackets()) {
+                $this->parseDomainLiteral();
+            }
+
+            $this->checkLabelLength($prev);
+
+            if ($this->isFWS()) {
+                $this->parseFWS();
+            }
+
+            $domain .= $this->lexer->token['value'];
+            $this->lexer->moveNext();
+        } while ($this->lexer->token);
+
+        return $domain;
+    }
+
+    protected function parseDomainLiteral()
+    {
+        if ($this->lexer->isNextToken(EmailLexer::S_COLON)) {
+            $this->warnings[] = EmailValidator::RFC5322_IPV6_COLONSTRT;
+        }
+        if ($this->lexer->isNextToken(EmailLexer::S_IPV6TAG)) {
+            $lexer = clone $this->lexer;
+            $lexer->moveNext();
+            if ($lexer->isNextToken(EmailLexer::S_DOUBLECOLON)) {
+                $this->warnings[] = EmailValidator::RFC5322_IPV6_COLONSTRT;
+            }
+        }
+
+        return $this->doParseDomainLiteral();
+    }
+
+    protected function doParseDomainLiteral()
+    {
+        $IPv6TAG = false;
+        $addressLiteral = '';
+        do {
+            if ($this->lexer->token['type'] === EmailLexer::C_NUL) {
+                throw new \InvalidArgumentException('ERR_EXPECTING_DTEXT');
+            }
+
+            if ($this->lexer->token['type'] === EmailLexer::INVALID ||
+                $this->lexer->token['type'] === EmailLexer::C_DEL   ||
+                $this->lexer->token['type'] === EmailLexer::S_LF
+            ) {
+                $this->warnings[] = EmailValidator::RFC5322_DOMLIT_OBSDTEXT;
+            }
+
+            if ($this->lexer->isNextTokenAny(array(EmailLexer::S_OPENQBRACKET, EmailLexer::S_OPENBRACKET))) {
+                throw new \InvalidArgumentException('ERR_EXPECTING_DTEXT');
+            }
+
+            if ($this->lexer->isNextTokenAny(
+                array(EmailLexer::S_HTAB, EmailLexer::S_SP, $this->lexer->token['type'] === EmailLexer::CRLF)
+            )) {
+                $this->warnings[] = EmailValidator::CFWS_FWS;
+                $this->parseFWS();
+            }
+
+            if ($this->lexer->isNextToken(EmailLexer::S_CR)) {
+                throw new \InvalidArgumentException("ERR_CR_NO_LF");
+            }
+            if ($this->lexer->token['type'] === EmailLexer::S_BACKSLASH) {
+                $this->warnings[] = EmailValidator::RFC5322_DOMLIT_OBSDTEXT;
+                $addressLiteral .= $this->lexer->token['value'];
+                $this->lexer->moveNext();
+                $this->validateQuotedPair();
+            }
+            if ($this->lexer->token['type'] === EmailLexer::S_IPV6TAG) {
+                $IPv6TAG = true;
+            }
+            if ($this->lexer->token['type'] === EmailLexer::S_CLOSEQBRACKET) {
+                break;
+            }
+
+            $addressLiteral .= $this->lexer->token['value'];
+
+        } while ($this->lexer->moveNext());
+
+        $addressLiteral = str_replace('[', '', $addressLiteral);
+        $addressLiteral = $this->checkIPV4Tag($addressLiteral);
+
+        if (false === $addressLiteral) {
+            return $addressLiteral;
+        }
+
+        if (!$IPv6TAG) {
+            $this->warnings[] = EmailValidator::RFC5322_DOMAINLITERAL;
+            return $addressLiteral;
+        }
+
+        $this->warnings[] = EmailValidator::RFC5321_ADDRESSLITERAL;
+
+        $this->checkIPV6Tag($addressLiteral);
+
+        return $addressLiteral;
+    }
+
+    protected function checkIPV4Tag($addressLiteral)
+    {
+        $matchesIP  = array();
+
+        // Extract IPv4 part from the end of the address-literal (if there is one)
+        if (preg_match(
+                '/\\b(?:(?:25[0-5]|2[0-4][0-9]|[01]?[0-9][0-9]?)\\.){3}(?:25[0-5]|2[0-4][0-9]|[01]?[0-9][0-9]?)$/',
+                $addressLiteral,
+                $matchesIP
+            ) > 0
+        ) {
+            $index = strrpos($addressLiteral, $matchesIP[0]);
+            if ($index === 0) {
+                $this->warnings[] = EmailValidator::RFC5321_ADDRESSLITERAL;
+                return false;
+            }
+            // Convert IPv4 part to IPv6 format for further testing
+            $addressLiteral = substr($addressLiteral, 0, $index) . '0:0';
+        }
+
+        return $addressLiteral;
+    }
+
+    protected function checkDomainPartExceptions($prev)
+    {
+        $invalidDomainTokens = array(
+            EmailLexer::S_DQUOTE => true,
+            EmailLexer::S_SEMICOLON => true,
+            EmailLexer::S_GREATERTHAN => true,
+            EmailLexer::S_LOWERTHAN => true,
+        );
+
+        if (isset($invalidDomainTokens[$this->lexer->token['type']])) {
+            throw new \InvalidArgumentException('ERR_EXPECTING_ATEXT');
+        }
+
+        if ($this->lexer->token['type'] === EmailLexer::S_COMMA) {
+            throw new \InvalidArgumentException('ERR_COMMA_IN_DOMAIN');
+        }
+
+        if ($this->lexer->token['type'] === EmailLexer::S_AT) {
+            throw new \InvalidArgumentException('ERR_CONSECUTIVEATS');
+        }
+
+        if ($this->lexer->token['type'] === EmailLexer::S_OPENQBRACKET && $prev['type'] !== EmailLexer::S_AT) {
+            throw new \InvalidArgumentException('ERR_EXPECTING_ATEXT');
+        }
+
+        if ($this->lexer->token['type'] === EmailLexer::S_HYPHEN && $this->lexer->isNextToken(EmailLexer::S_DOT)) {
+            throw new \InvalidArgumentException('ERR_DOMAINHYPHENEND');
+        }
+
+        if ($this->lexer->token['type'] === EmailLexer::S_BACKSLASH
+            && $this->lexer->isNextToken(EmailLexer::GENERIC)) {
+            throw new \InvalidArgumentException('ERR_EXPECTING_ATEXT');
+        }
+    }
+
+    protected function hasBrackets()
+    {
+        if ($this->lexer->token['type'] !== EmailLexer::S_OPENBRACKET) {
+            return false;
+        }
+
+        try {
+            $this->lexer->find(EmailLexer::S_CLOSEBRACKET);
+        } catch (\RuntimeException $e) {
+            throw new \InvalidArgumentException('ERR_EXPECTING_DOMLIT_CLOSE');
+        }
+
+        return true;
+    }
+
+    protected function checkLabelLength($prev)
+    {
+        if ($this->lexer->token['type'] === EmailLexer::S_DOT &&
+            $prev['type'] === EmailLexer::GENERIC &&
+            strlen($prev['value']) > 63
+        ) {
+            $this->warnings[] = EmailValidator::RFC5322_LABEL_TOOLONG;
+        }
+    }
+
+    protected function parseDomainComments()
+    {
+        $this->isUnclosedComment();
+        while (!$this->lexer->isNextToken(EmailLexer::S_CLOSEPARENTHESIS)) {
+            $this->warnEscaping();
+            $this->lexer->moveNext();
+        }
+
+        $this->lexer->moveNext();
+        if ($this->lexer->isNextToken(EmailLexer::S_DOT)) {
+            throw new \InvalidArgumentException('ERR_EXPECTING_ATEXT');
+        }
+    }
+}

vendor/egulias/email-validator/src/Egulias/EmailValidator/Parser/LocalPart.php

@@ -0,0 +1,121 @@
+<?php
+
+namespace Egulias\EmailValidator\Parser;
+
+use Egulias\EmailValidator\EmailLexer;
+use Egulias\EmailValidator\EmailValidator;
+use \InvalidArgumentException;
+
+class LocalPart extends Parser
+{
+    public function parse($localPart)
+    {
+        $parseDQuote = true;
+        $closingQuote = false;
+
+        while ($this->lexer->token['type'] !== EmailLexer::S_AT && $this->lexer->token) {
+
+            if ($this->lexer->token['type'] === EmailLexer::S_DOT && !$this->lexer->getPrevious()) {
+                throw new \InvalidArgumentException('ERR_DOT_START');
+            }
+
+            $closingQuote = $this->checkDQUOTE($closingQuote);
+            if ($closingQuote && $parseDQuote) {
+                $parseDQuote = $this->parseDoubleQuote();
+            }
+
+            if ($this->lexer->token['type'] === EmailLexer::S_OPENPARENTHESIS) {
+                $this->parseComments();
+            }
+
+            $this->checkConsecutiveDots();
+
+            if (
+                $this->lexer->token['type'] === EmailLexer::S_DOT &&
+                $this->lexer->isNextToken(EmailLexer::S_AT)
+            ) {
+                throw new \InvalidArgumentException('ERR_DOT_END');
+            }
+
+            $this->warnEscaping();
+            $this->isInvalidToken($this->lexer->token, $closingQuote);
+
+            if ($this->isFWS()) {
+                $this->parseFWS();
+            }
+
+            $this->lexer->moveNext();
+        }
+
+        $prev = $this->lexer->getPrevious();
+        if (strlen($prev['value']) > EmailValidator::RFC5322_LOCAL_TOOLONG) {
+            $this->warnings[] = EmailValidator::RFC5322_LOCAL_TOOLONG;
+        }
+    }
+
+    protected function parseDoubleQuote()
+    {
+        $parseAgain = true;
+        $special = array(
+            EmailLexer::S_CR => true,
+            EmailLexer::S_HTAB => true,
+            EmailLexer::S_LF => true
+        );
+
+        $invalid = array(
+            EmailLexer::C_NUL => true,
+            EmailLexer::S_HTAB => true,
+            EmailLexer::S_CR => true,
+            EmailLexer::S_LF => true
+        );
+        $setSpecialsWarning = true;
+
+        $this->lexer->moveNext();
+
+        while ($this->lexer->token['type'] !== EmailLexer::S_DQUOTE && $this->lexer->token) {
+            $parseAgain = false;
+            if (isset($special[$this->lexer->token['type']]) && $setSpecialsWarning) {
+                $this->warnings[] = EmailValidator::CFWS_FWS;
+                $setSpecialsWarning = false;
+            }
+
+            $this->lexer->moveNext();
+
+            if (!$this->escaped() && isset($invalid[$this->lexer->token['type']])) {
+                throw new InvalidArgumentException("ERR_EXPECTED_ATEXT");
+            }
+        }
+
+        $prev = $this->lexer->getPrevious();
+
+        if ($prev['type'] === EmailLexer::S_BACKSLASH) {
+            if (!$this->checkDQUOTE(false)) {
+                throw new \InvalidArgumentException("ERR_UNCLOSED_DQUOTE");
+            }
+        }
+
+        if (!$this->lexer->isNextToken(EmailLexer::S_AT) && $prev['type'] !== EmailLexer::S_BACKSLASH) {
+            throw new \InvalidArgumentException("ERR_EXPECED_AT");
+        }
+
+        return $parseAgain;
+    }
+
+    protected function isInvalidToken($token, $closingQuote)
+    {
+        $forbidden = array(
+            EmailLexer::S_COMMA,
+            EmailLexer::S_CLOSEBRACKET,
+            EmailLexer::S_OPENBRACKET,
+            EmailLexer::S_GREATERTHAN,
+            EmailLexer::S_LOWERTHAN,
+            EmailLexer::S_COLON,
+            EmailLexer::S_SEMICOLON,
+            EmailLexer::INVALID
+        );
+
+        if (in_array($token['type'], $forbidden) && !$closingQuote) {
+            throw new \InvalidArgumentException('ERR_EXPECTING_ATEXT');
+        }
+    }
+}

vendor/egulias/email-validator/src/Egulias/EmailValidator/Parser/Parser.php

@@ -0,0 +1,190 @@
+<?php
+
+namespace Egulias\EmailValidator\Parser;
+
+use Egulias\EmailValidator\EmailLexer;
+use Egulias\EmailValidator\EmailValidator;
+
+abstract class Parser
+{
+    protected $warnings = array();
+    protected $lexer;
+
+    public function __construct(EmailLexer $lexer)
+    {
+        $this->lexer = $lexer;
+    }
+
+    public function getWarnings()
+    {
+        return $this->warnings;
+    }
+
+    abstract function parse($str);
+
+    /**
+     * validateQuotedPair
+     */
+    protected function validateQuotedPair()
+    {
+        if (!($this->lexer->token['type'] === EmailLexer::INVALID
+            || $this->lexer->token['type'] === EmailLexer::C_DEL)) {
+            throw new \InvalidArgumentException('ERR_EXPECTING_QPAIR');
+        }
+
+        $this->warnings[] = EmailValidator::DEPREC_QP;
+    }
+
+    /**
+     * @return string the the comment
+     * @throws \InvalidArgumentException
+     */
+    protected function parseComments()
+    {
+        $this->isUnclosedComment();
+        $this->warnings[] = EmailValidator::CFWS_COMMENT;
+        while (!$this->lexer->isNextToken(EmailLexer::S_CLOSEPARENTHESIS)) {
+            $this->warnEscaping();
+            $this->lexer->moveNext();
+        }
+
+        $this->lexer->moveNext();
+        if ($this->lexer->isNextTokenAny(array(EmailLexer::GENERIC, EmailLexer::S_EMPTY))) {
+            throw new \InvalidArgumentException('ERR_EXPECTING_ATEXT');
+        }
+
+        if ($this->lexer->isNextToken(EmailLexer::S_AT)) {
+            $this->warnings[] = EmailValidator::DEPREC_CFWS_NEAR_AT;
+        }
+    }
+
+    protected function isUnclosedComment()
+    {
+        try {
+            $this->lexer->find(EmailLexer::S_CLOSEPARENTHESIS);
+            return true;
+        } catch (\RuntimeException $e) {
+            throw new \InvalidArgumentException('ERR_UNCLOSEDCOMMENT');
+        }
+    }
+
+    protected function parseFWS()
+    {
+        $previous = $this->lexer->getPrevious();
+
+        $this->checkCRLFInFWS();
+
+        if ($this->lexer->token['type'] === EmailLexer::S_CR) {
+            throw new \InvalidArgumentException("ERR_CR_NO_LF");
+        }
+
+        if ($this->lexer->isNextToken(EmailLexer::GENERIC) && $previous['type']  !== EmailLexer::S_AT) {
+            throw new \InvalidArgumentException("ERR_ATEXT_AFTER_CFWS");
+        }
+
+        if ($this->lexer->token['type'] === EmailLexer::S_LF || $this->lexer->token['type'] === EmailLexer::C_NUL) {
+            throw new \InvalidArgumentException('ERR_EXPECTING_CTEXT');
+        }
+
+        if ($this->lexer->isNextToken(EmailLexer::S_AT) || $previous['type']  === EmailLexer::S_AT) {
+            $this->warnings[] = EmailValidator::DEPREC_CFWS_NEAR_AT;
+        } else {
+            $this->warnings[] = EmailValidator::CFWS_FWS;
+        }
+    }
+
+    protected function checkConsecutiveDots()
+    {
+        if ($this->lexer->token['type'] === EmailLexer::S_DOT && $this->lexer->isNextToken(EmailLexer::S_DOT)) {
+            throw new \InvalidArgumentException('ERR_CONSECUTIVEDOTS');
+        }
+    }
+
+    protected function isFWS()
+    {
+        if ($this->escaped()) {
+            return false;
+        }
+
+        if ($this->lexer->token['type'] === EmailLexer::S_SP ||
+            $this->lexer->token['type'] === EmailLexer::S_HTAB ||
+            $this->lexer->token['type'] === EmailLexer::S_CR ||
+            $this->lexer->token['type'] === EmailLexer::S_LF ||
+            $this->lexer->token['type'] === EmailLexer::CRLF
+        ) {
+            return true;
+        }
+
+        return false;
+    }
+
+    protected function escaped()
+    {
+        $previous = $this->lexer->getPrevious();
+
+        if ($previous['type'] === EmailLexer::S_BACKSLASH
+            &&
+            $this->lexer->token['type'] !== EmailLexer::GENERIC
+        ) {
+            return true;
+        }
+
+        return false;
+    }
+
+    protected function warnEscaping()
+    {
+        if ($this->lexer->token['type'] !== EmailLexer::S_BACKSLASH) {
+            return false;
+        }
+
+        if ($this->lexer->isNextToken(EmailLexer::GENERIC)) {
+            throw new \InvalidArgumentException('ERR_EXPECTING_ATEXT');
+        }
+
+        if (!$this->lexer->isNextTokenAny(array(EmailLexer::S_SP, EmailLexer::S_HTAB, EmailLexer::C_DEL))) {
+            return false;
+        }
+
+        $this->warnings[] = EmailValidator::DEPREC_QP;
+        return true;
+
+    }
+
+    protected function checkDQUOTE($hasClosingQuote)
+    {
+        if ($this->lexer->token['type'] !== EmailLexer::S_DQUOTE) {
+            return $hasClosingQuote;
+        }
+        if ($hasClosingQuote) {
+            return $hasClosingQuote;
+        }
+        $previous = $this->lexer->getPrevious();
+        if ($this->lexer->isNextToken(EmailLexer::GENERIC) && $previous['type'] === EmailLexer::GENERIC) {
+            throw new \InvalidArgumentException('ERR_EXPECTING_ATEXT');
+        }
+
+        $this->warnings[] = EmailValidator::RFC5321_QUOTEDSTRING;
+        try {
+            $this->lexer->find(EmailLexer::S_DQUOTE);
+            $hasClosingQuote = true;
+        } catch (\Exception $e) {
+            throw new \InvalidArgumentException('ERR_UNCLOSEDQUOTEDSTR');
+        }
+
+        return $hasClosingQuote;
+    }
+
+    protected function checkCRLFInFWS()
+    {
+        if ($this->lexer->token['type'] !== EmailLexer::CRLF) {
+            return;
+        }
+        if ($this->lexer->isNextToken(EmailLexer::CRLF)) {
+            throw new \InvalidArgumentException("ERR_FWS_CRLF_X2");
+        }
+        if (!$this->lexer->isNextTokenAny(array(EmailLexer::S_SP, EmailLexer::S_HTAB))) {
+            throw new \InvalidArgumentException("ERR_FWS_CRLF_END");
+        }
+    }
+}