[a-f\d\.\:]+)\])?$~i';
+ if (preg_match($pattern, $value, $matches)) {
+ if (!empty($matches['name'])) {
+ $hostname = $matches['name'];
+ }
+ if (!empty($matches['addr'])) {
+ $address = $matches['addr'];
+ }
+ return true;
+ }
+ return false;
+ }
+
+ /**
+ * Creates a single ReceivedDomainPart out of matched parts. If an
+ * unmatched parenthesized expression was found, it's returned as a
+ * CommentPart.
+ *
+ * @param \ZBateson\MailMimeParser\Header\Part\HeaderPart[] $parts
+ * @return \ZBateson\MailMimeParser\Header\Part\ReceivedDomainPart[]|
+ * \ZBateson\MailMimeParser\Header\Part\CommentPart[]array
+ */
+ protected function processParts(array $parts)
+ {
+ $ehloName = null;
+ $hostname = null;
+ $address = null;
+ $commentPart = null;
+
+ $filtered = $this->filterIgnoredSpaces($parts);
+ foreach ($filtered as $part) {
+ if ($part instanceof CommentPart) {
+ $commentPart = $part;
+ continue;
+ }
+ $ehloName .= $part->getValue();
+ }
+
+ $strValue = $ehloName;
+ if ($commentPart !== null && $this->matchHostPart($commentPart->getComment(), $hostname, $address)) {
+ $strValue .= ' (' . $commentPart->getComment() . ')';
+ $commentPart = null;
+ }
+
+ $domainPart = $this->partFactory->newReceivedDomainPart(
+ $this->getPartName(),
+ $strValue,
+ $ehloName,
+ $hostname,
+ $address
+ );
+ return array_filter([ $domainPart, $commentPart ]);
+ }
+}
diff --git a/hdz/vendor/zbateson/mail-mime-parser/src/Header/Consumer/Received/GenericReceivedConsumer.php b/hdz/vendor/zbateson/mail-mime-parser/src/Header/Consumer/Received/GenericReceivedConsumer.php
new file mode 100644
index 0000000..62bf9a7
--- /dev/null
+++ b/hdz/vendor/zbateson/mail-mime-parser/src/Header/Consumer/Received/GenericReceivedConsumer.php
@@ -0,0 +1,155 @@
+partName = $partName;
+ }
+
+ /**
+ * Returns the name of the part being parsed.
+ *
+ * This is always the lower-case name provided to the constructor, not the
+ * actual string that started the consumer, which could be in any case.
+ *
+ * @return string
+ */
+ protected function getPartName()
+ {
+ return $this->partName;
+ }
+
+ /**
+ * Overridden to return a CommentConsumer.
+ *
+ * @return AbstractConsumer[] the sub-consumers
+ */
+ protected function getSubConsumers()
+ {
+ return [ $this->consumerService->getCommentConsumer() ];
+ }
+
+ /**
+ * Returns true if the passed token matches (case-insensitively)
+ * $this->getPartName() with optional whitespace surrounding it.
+ *
+ * @param string $token
+ * @return bool
+ */
+ protected function isStartToken($token)
+ {
+ $pattern = '/^\s*(' . preg_quote($this->getPartName(), '/') . ')\s*$/i';
+ return (preg_match($pattern, $token) === 1);
+ }
+
+ /**
+ * Returns true if the token matches (case-insensitively) any of the
+ * following, with optional surrounding whitespace:
+ *
+ * o from
+ * o by
+ * o via
+ * o with
+ * o id
+ * o for
+ * o ;
+ *
+ * @param string $token
+ * @return boolean
+ */
+ protected function isEndToken($token)
+ {
+ return (preg_match('/^\s*(from|by|via|with|id|for|;)\s*$/i', $token) === 1);
+ }
+
+ /**
+ * Returns a whitespace separator (for filtering ignorable whitespace
+ * between parts), and a separator matching the current part name as
+ * returned by $this->getPartName().
+ *
+ * @return string[] an array of regex pattern matchers
+ */
+ protected function getTokenSeparators()
+ {
+ return [
+ '\s+',
+ '(\A\s*)?(?i)' . preg_quote($this->getPartName(), '/') . '(?-i)\s+'
+ ];
+ }
+
+ /**
+ * Overridden to combine all part values into a single string and return it
+ * as the first element, followed by any comment elements as subsequent
+ * elements.
+ *
+ * @param \ZBateson\MailMimeParser\Header\Part\HeaderPart[] $parts
+ * @return \ZBateson\MailMimeParser\Header\Part\HeaderPart[]|
+ * \ZBateson\MailMimeParser\Header\Part\CommentPart[]|
+ * array
+ */
+ protected function processParts(array $parts)
+ {
+ $strValue = '';
+ $ret = [];
+ $filtered = $this->filterIgnoredSpaces($parts);
+ foreach ($filtered as $part) {
+ if ($part instanceof CommentPart) {
+ $ret[] = $part;
+ continue; // getValue() is empty anyway, but for clarity...
+ }
+ $strValue .= $part->getValue();
+ }
+ array_unshift($ret, $this->partFactory->newReceivedPart($this->getPartName(), $strValue));
+ return $ret;
+ }
+}
diff --git a/hdz/vendor/zbateson/mail-mime-parser/src/Header/Consumer/Received/ReceivedDateConsumer.php b/hdz/vendor/zbateson/mail-mime-parser/src/Header/Consumer/Received/ReceivedDateConsumer.php
new file mode 100644
index 0000000..a46835c
--- /dev/null
+++ b/hdz/vendor/zbateson/mail-mime-parser/src/Header/Consumer/Received/ReceivedDateConsumer.php
@@ -0,0 +1,41 @@
+consumerService->getSubReceivedConsumer('from'),
+ $this->consumerService->getSubReceivedConsumer('by'),
+ $this->consumerService->getSubReceivedConsumer('via'),
+ $this->consumerService->getSubReceivedConsumer('with'),
+ $this->consumerService->getSubReceivedConsumer('id'),
+ $this->consumerService->getSubReceivedConsumer('for'),
+ $this->consumerService->getSubReceivedConsumer('date'),
+ $this->consumerService->getCommentConsumer()
+ ];
+ }
+
+ /**
+ * Overridden to exclude the MimeLiteralPart pattern that comes by default
+ * in AbstractConsumer.
+ *
+ * @return string the regex pattern
+ */
+ protected function getTokenSplitPattern()
+ {
+ $sChars = implode('|', $this->getAllTokenSeparators());
+ return '~(' . $sChars . ')~';
+ }
+
+ /**
+ * Overridden to /not/ advance when the end token matches a start token for
+ * a sub-consumer.
+ *
+ * @param Iterator $tokens
+ * @param bool $isStartToken
+ */
+ protected function advanceToNextToken(Iterator $tokens, $isStartToken)
+ {
+ if ($isStartToken) {
+ $tokens->next();
+ } elseif ($tokens->valid() && !$this->isEndToken($tokens->current())) {
+ foreach ($this->getSubConsumers() as $consumer) {
+ if ($consumer->isStartToken($tokens->current())) {
+ return;
+ }
+ }
+ $tokens->next();
+ }
+ }
+
+ /**
+ * Overridden to combine all part values into a single string and return it
+ * as an array with a single element.
+ *
+ * @param \ZBateson\MailMimeParser\Header\Part\HeaderPart[] $parts
+ * @return \ZBateson\MailMimeParser\Header\Part\HeaderPart[]|
+ * \ZBateson\MailMimeParser\Header\Part\ReceivedDomainPart[]|
+ * \ZBateson\MailMimeParser\Header\Part\ReceivedPart[]|
+ * \ZBateson\MailMimeParser\Header\Part\DatePart[]|
+ * \ZBateson\MailMimeParser\Header\Part\CommentPart[]|array
+ */
+ protected function processParts(array $parts)
+ {
+ $ret = [];
+ foreach ($parts as $part) {
+ if ($part instanceof Token) {
+ continue;
+ }
+ $ret[] = $part;
+ }
+ return $ret;
+ }
+}
diff --git a/hdz/vendor/zbateson/mail-mime-parser/src/Header/Consumer/SubjectConsumer.php b/hdz/vendor/zbateson/mail-mime-parser/src/Header/Consumer/SubjectConsumer.php
new file mode 100644
index 0000000..1e74843
--- /dev/null
+++ b/hdz/vendor/zbateson/mail-mime-parser/src/Header/Consumer/SubjectConsumer.php
@@ -0,0 +1,95 @@
+partFactory->newLiteralPart($token);
+ } elseif (preg_match('/^\s+$/', $token)) {
+ if (preg_match('/^[\r\n]/', $token)) {
+ return $this->partFactory->newToken(' ');
+ }
+ return $this->partFactory->newToken($token);
+ }
+ return $this->partFactory->newInstance($token);
+ }
+
+ /**
+ * Returns an array of \ZBateson\MailMimeParser\Header\Part\HeaderPart for
+ * the current token on the iterator.
+ *
+ * Overridden from AbstractConsumer to remove special filtering for
+ * backslash escaping, which also seems to not apply to Subject headers at
+ * least in ThunderBird's implementation.
+ *
+ * @param Iterator $tokens
+ * @return \ZBateson\MailMimeParser\Header\Part\HeaderPart[]|array
+ */
+ protected function getTokenParts(Iterator $tokens)
+ {
+ return $this->getConsumerTokenParts($tokens);
+ }
+
+ /**
+ * Overridden to not split out backslash characters and its next character
+ * as a special case defined in AbastractConsumer
+ *
+ * @return string the regex pattern
+ */
+ protected function getTokenSplitPattern()
+ {
+ $sChars = implode('|', $this->getAllTokenSeparators());
+ return '~(' . $sChars . ')~';
+ }
+}
diff --git a/hdz/vendor/zbateson/mail-mime-parser/src/Header/DateHeader.php b/hdz/vendor/zbateson/mail-mime-parser/src/Header/DateHeader.php
new file mode 100644
index 0000000..3dffcd9
--- /dev/null
+++ b/hdz/vendor/zbateson/mail-mime-parser/src/Header/DateHeader.php
@@ -0,0 +1,42 @@
+getDateConsumer();
+ }
+
+ /**
+ * Convenience method returning the part's DateTime object.
+ *
+ * @return \DateTime
+ */
+ public function getDateTime()
+ {
+ if (!empty($this->parts) && $this->parts[0] instanceof DatePart) {
+ return $this->parts[0]->getDateTime();
+ }
+ return null;
+ }
+}
diff --git a/hdz/vendor/zbateson/mail-mime-parser/src/Header/GenericHeader.php b/hdz/vendor/zbateson/mail-mime-parser/src/Header/GenericHeader.php
new file mode 100644
index 0000000..bf7a65e
--- /dev/null
+++ b/hdz/vendor/zbateson/mail-mime-parser/src/Header/GenericHeader.php
@@ -0,0 +1,31 @@
+getGenericConsumer();
+ }
+}
diff --git a/hdz/vendor/zbateson/mail-mime-parser/src/Header/HeaderConsts.php b/hdz/vendor/zbateson/mail-mime-parser/src/Header/HeaderConsts.php
new file mode 100644
index 0000000..36f10af
--- /dev/null
+++ b/hdz/vendor/zbateson/mail-mime-parser/src/Header/HeaderConsts.php
@@ -0,0 +1,40 @@
+headerFactory = $headerFactory;
+ }
+
+ /**
+ * Returns true if the passed header exists in this collection.
+ *
+ * @param string $name
+ * @param int $offset
+ * @return boolean
+ */
+ public function exists($name, $offset = 0)
+ {
+ $s = $this->headerFactory->getNormalizedHeaderName($name);
+ return isset($this->headerMap[$s][$offset]);
+ }
+
+ /**
+ * Returns an array of header indexes with names that more closely match
+ * the passed $name if available: for instance if there are two headers in
+ * an email, "Content-Type" and "ContentType", and the query is for a header
+ * with the name "Content-Type", only headers that match exactly
+ * "Content-Type" would be returned.
+ *
+ * @param string $name
+ * @return int[]
+ */
+ private function getAllWithOriginalHeaderNameIfSet($name)
+ {
+ $s = $this->headerFactory->getNormalizedHeaderName($name);
+ if (isset($this->headerMap[$s])) {
+ $self = $this;
+ $filtered = array_filter($this->headerMap[$s], function ($h) use ($name, $self) {
+ return (strcasecmp($self->headers[$h][0], $name) === 0);
+ });
+ return (!empty($filtered)) ? $filtered : $this->headerMap[$s];
+ }
+ return null;
+ }
+
+ /**
+ * Returns the AbstractHeader object for the header with the given $name and
+ * at the optional offset (defaulting to the first header in the collection
+ * where more than one header with the same name exists).
+ *
+ * Note that mime headers aren't case sensitive.
+ *
+ * @param string $name
+ * @param int $offset
+ * @return \ZBateson\MailMimeParser\Header\AbstractHeader
+ */
+ public function get($name, $offset = 0)
+ {
+ $a = $this->getAllWithOriginalHeaderNameIfSet($name);
+ if (!empty($a) && isset($a[$offset])) {
+ return $this->getByIndex($a[$offset]);
+ }
+ return null;
+ }
+
+ /**
+ * Returns all headers with the passed name.
+ *
+ * @param string $name
+ * @return \ZBateson\MailMimeParser\Header\AbstractHeader[]
+ */
+ public function getAll($name)
+ {
+ $a = $this->getAllWithOriginalHeaderNameIfSet($name);
+ if (!empty($a)) {
+ $self = $this;
+ return array_map(function ($index) use ($self) {
+ return $self->getByIndex($index);
+ }, $a);
+ }
+ return [];
+ }
+
+ /**
+ * Returns the header in the headers array at the passed 0-based integer
+ * index.
+ *
+ * @param int $index
+ * @return \ZBateson\MailMimeParser\Header\AbstractHeader
+ */
+ private function getByIndex($index)
+ {
+ if (!isset($this->headers[$index])) {
+ return null;
+ }
+ if ($this->headerObjects[$index] === null) {
+ $this->headerObjects[$index] = $this->headerFactory->newInstance(
+ $this->headers[$index][0],
+ $this->headers[$index][1]
+ );
+ }
+ return $this->headerObjects[$index];
+ }
+
+ /**
+ * Removes the header from the collection with the passed name. Defaults to
+ * removing the first instance of the header for a collection that contains
+ * more than one with the same passed name.
+ *
+ * @param string $name
+ * @param int $offset
+ * @return boolean
+ */
+ public function remove($name, $offset = 0)
+ {
+ $s = $this->headerFactory->getNormalizedHeaderName($name);
+ if (isset($this->headerMap[$s][$offset])) {
+ $index = $this->headerMap[$s][$offset];
+ array_splice($this->headerMap[$s], $offset, 1);
+ unset($this->headers[$index]);
+ unset($this->headerObjects[$index]);
+ return true;
+ }
+ return false;
+ }
+
+ /**
+ * Removes all headers that match the passed name.
+ *
+ * @param string $name
+ * @return boolean
+ */
+ public function removeAll($name)
+ {
+ $s = $this->headerFactory->getNormalizedHeaderName($name);
+ if (!empty($this->headerMap[$s])) {
+ foreach ($this->headerMap[$s] as $i) {
+ unset($this->headers[$i]);
+ unset($this->headerObjects[$i]);
+ }
+ $this->headerMap[$s] = [];
+ return true;
+ }
+ return false;
+ }
+
+ /**
+ * Adds the header to the collection.
+ *
+ * @param string $name
+ * @param string $value
+ */
+ public function add($name, $value)
+ {
+ $s = $this->headerFactory->getNormalizedHeaderName($name);
+ $this->headers[$this->nextIndex] = [ $name, $value ];
+ $this->headerObjects[$this->nextIndex] = null;
+ if (!isset($this->headerMap[$s])) {
+ $this->headerMap[$s] = [];
+ }
+ array_push($this->headerMap[$s], $this->nextIndex);
+ $this->nextIndex++;
+ }
+
+ /**
+ * If a header exists with the passed name, and at the passed offset if more
+ * than one exists, its value is updated.
+ *
+ * If a header with the passed name doesn't exist at the passed offset, it
+ * is created at the next available offset (offset is ignored when adding).
+ *
+ * @param string $name
+ * @param string $value
+ * @param int $offset
+ */
+ public function set($name, $value, $offset = 0)
+ {
+ $s = $this->headerFactory->getNormalizedHeaderName($name);
+ if (!isset($this->headerMap[$s][$offset])) {
+ $this->add($name, $value);
+ return;
+ }
+ $i = $this->headerMap[$s][$offset];
+ $this->headers[$i] = [ $name, $value ];
+ $this->headerObjects[$i] = null;
+ }
+
+ /**
+ * Returns an array of AbstractHeader objects representing all headers in
+ * this collection.
+ *
+ * @return AbstractHeader
+ */
+ public function getHeaderObjects()
+ {
+ return array_filter(array_map([ $this, 'getByIndex' ], array_keys($this->headers)));
+ }
+
+ /**
+ * Returns an array of headers in this collection. Each returned element in
+ * the array is an array with the first element set to the name, and the
+ * second its value:
+ *
+ * [
+ * [ 'Header-Name', 'Header Value' ],
+ * [ 'Second-Header-Name', 'Second-Header-Value' ],
+ * // etc...
+ * ]
+ *
+ * @return string[][]
+ */
+ public function getHeaders()
+ {
+ return array_values(array_filter($this->headers));
+ }
+
+ /**
+ * Returns an iterator to the headers in this collection. Each returned
+ * element is an array with its first element set to the header's name, and
+ * the second to its value:
+ *
+ * [ 'Header-Name', 'Header Value' ]
+ *
+ * @return ArrayIterator
+ */
+ public function getIterator()
+ {
+ return new ArrayIterator($this->getHeaders());
+ }
+}
diff --git a/hdz/vendor/zbateson/mail-mime-parser/src/Header/HeaderFactory.php b/hdz/vendor/zbateson/mail-mime-parser/src/Header/HeaderFactory.php
new file mode 100644
index 0000000..18f84bd
--- /dev/null
+++ b/hdz/vendor/zbateson/mail-mime-parser/src/Header/HeaderFactory.php
@@ -0,0 +1,168 @@
+ [
+ 'from',
+ 'to',
+ 'cc',
+ 'bcc',
+ 'sender',
+ 'replyto',
+ 'resentfrom',
+ 'resentto',
+ 'resentcc',
+ 'resentbcc',
+ 'resentreplyto',
+ 'returnpath',
+ 'deliveredto',
+ ],
+ 'ZBateson\MailMimeParser\Header\DateHeader' => [
+ 'date',
+ 'resentdate',
+ 'deliverydate',
+ 'expires',
+ 'expirydate',
+ 'replyby',
+ ],
+ 'ZBateson\MailMimeParser\Header\ParameterHeader' => [
+ 'contenttype',
+ 'contentdisposition',
+ ],
+ 'ZBateson\MailMimeParser\Header\SubjectHeader' => [
+ 'subject',
+ ],
+ 'ZBateson\MailMimeParser\Header\IdHeader' => [
+ 'messageid',
+ 'contentid',
+ 'inreplyto',
+ 'references'
+ ],
+ 'ZBateson\MailMimeParser\Header\ReceivedHeader' => [
+ 'received'
+ ]
+ ];
+
+ /**
+ * @var string Defines the generic AbstractHeader type to use for headers
+ * that aren't mapped in $types
+ */
+ protected $genericType = 'ZBateson\MailMimeParser\Header\GenericHeader';
+
+ /**
+ * Instantiates member variables with the passed objects.
+ *
+ * @param ConsumerService $consumerService
+ * @param MimeLiteralPartFactory $mimeLiteralPartFactory
+ */
+ public function __construct(ConsumerService $consumerService, MimeLiteralPartFactory $mimeLiteralPartFactory)
+ {
+ $this->consumerService = $consumerService;
+ $this->mimeLiteralPartFactory = $mimeLiteralPartFactory;
+ }
+
+ /**
+ * Returns the string in lower-case, and with non-alphanumeric characters
+ * stripped out.
+ *
+ * @param string $header
+ * @return string
+ */
+ public function getNormalizedHeaderName($header)
+ {
+ return preg_replace('/[^a-z0-9]/', '', strtolower($header));
+ }
+
+ /**
+ * Returns the name of an AbstractHeader class for the passed header name.
+ *
+ * @param string $name
+ * @return string
+ */
+ private function getClassFor($name)
+ {
+ $test = $this->getNormalizedHeaderName($name);
+ foreach ($this->types as $class => $matchers) {
+ foreach ($matchers as $matcher) {
+ if ($test === $matcher) {
+ return $class;
+ }
+ }
+ }
+ return $this->genericType;
+ }
+
+ /**
+ * Creates an AbstractHeader instance for the passed header name and value,
+ * and returns it.
+ *
+ * @param string $name
+ * @param string $value
+ * @return \ZBateson\MailMimeParser\Header\AbstractHeader
+ */
+ public function newInstance($name, $value)
+ {
+ $class = $this->getClassFor($name);
+ if (is_a($class, 'ZBateson\MailMimeParser\Header\MimeEncodedHeader', true)) {
+ return new $class(
+ $this->mimeLiteralPartFactory,
+ $this->consumerService,
+ $name,
+ $value
+ );
+ }
+ return new $class($this->consumerService, $name, $value);
+ }
+
+ /**
+ * Creates and returns a HeaderContainer.
+ *
+ * @return HeaderContainer;
+ */
+ public function newHeaderContainer()
+ {
+ return new HeaderContainer($this);
+ }
+}
diff --git a/hdz/vendor/zbateson/mail-mime-parser/src/Header/IdHeader.php b/hdz/vendor/zbateson/mail-mime-parser/src/Header/IdHeader.php
new file mode 100644
index 0000000..e741d68
--- /dev/null
+++ b/hdz/vendor/zbateson/mail-mime-parser/src/Header/IdHeader.php
@@ -0,0 +1,53 @@
+getIdBaseConsumer();
+ }
+
+ /**
+ * Synonym for getValue().
+ *
+ * @return string|null
+ */
+ public function getId()
+ {
+ return $this->getValue();
+ }
+
+ /**
+ * Returns all IDs parsed for a multi-id header like References or
+ * In-Reply-To.
+ *
+ * @return string[]
+ */
+ public function getIds()
+ {
+ return $this->parts;
+ }
+}
diff --git a/hdz/vendor/zbateson/mail-mime-parser/src/Header/MimeEncodedHeader.php b/hdz/vendor/zbateson/mail-mime-parser/src/Header/MimeEncodedHeader.php
new file mode 100644
index 0000000..ccd5a5d
--- /dev/null
+++ b/hdz/vendor/zbateson/mail-mime-parser/src/Header/MimeEncodedHeader.php
@@ -0,0 +1,64 @@
+mimeLiteralPartFactory = $mimeLiteralPartFactory;
+ parent::__construct($consumerService, $name, $value);
+ }
+
+ /**
+ * Mime-decodes the raw value if the whole raw value only consists of mime-
+ * encoded parts and whitespace prior to invoking the passed consumer.
+ *
+ * @param AbstractConsumer $consumer
+ */
+ protected function setParseHeaderValue(AbstractConsumer $consumer)
+ {
+ $value = $this->rawValue;
+ $matchp = '~^(\s*' . MimeLiteralPart::MIME_PART_PATTERN . '\s*)+$~';
+ if (preg_match($matchp, $value)) {
+ $p = $this->mimeLiteralPartFactory->newInstance($value);
+ $value = $p->getValue();
+ }
+ $this->parts = $consumer($value);
+ }
+}
diff --git a/hdz/vendor/zbateson/mail-mime-parser/src/Header/ParameterHeader.php b/hdz/vendor/zbateson/mail-mime-parser/src/Header/ParameterHeader.php
new file mode 100644
index 0000000..370e614
--- /dev/null
+++ b/hdz/vendor/zbateson/mail-mime-parser/src/Header/ParameterHeader.php
@@ -0,0 +1,80 @@
+getParameterConsumer();
+ }
+
+ /**
+ * Overridden to assign ParameterParts to a map of lower-case parameter
+ * names to ParameterParts.
+ *
+ * @param AbstractConsumer $consumer
+ */
+ protected function setParseHeaderValue(AbstractConsumer $consumer)
+ {
+ parent::setParseHeaderValue($consumer);
+ foreach ($this->parts as $part) {
+ if ($part instanceof ParameterPart) {
+ $this->parameters[strtolower($part->getName())] = $part;
+ }
+ }
+ }
+
+ /**
+ * Returns true if a parameter exists with the passed name.
+ *
+ * @param string $name
+ * @return boolean
+ */
+ public function hasParameter($name)
+ {
+ return isset($this->parameters[strtolower($name)]);
+ }
+
+ /**
+ * Returns the value of the parameter with the given name, or $defaultValue
+ * if not set.
+ *
+ * @param string $name
+ * @param string $defaultValue
+ * @return string
+ */
+ public function getValueFor($name, $defaultValue = null)
+ {
+ if (!$this->hasParameter($name)) {
+ return $defaultValue;
+ }
+ return $this->parameters[strtolower($name)]->getValue();
+ }
+}
diff --git a/hdz/vendor/zbateson/mail-mime-parser/src/Header/Part/AddressGroupPart.php b/hdz/vendor/zbateson/mail-mime-parser/src/Header/Part/AddressGroupPart.php
new file mode 100644
index 0000000..18c2208
--- /dev/null
+++ b/hdz/vendor/zbateson/mail-mime-parser/src/Header/Part/AddressGroupPart.php
@@ -0,0 +1,75 @@
+addresses = $addresses;
+ }
+
+ /**
+ * Return the AddressGroupPart's array of addresses.
+ *
+ * @return AddressPart[]
+ */
+ public function getAddresses()
+ {
+ return $this->addresses;
+ }
+
+ /**
+ * Returns the AddressPart at the passed index or null.
+ *
+ * @param int $index
+ * @return Address
+ */
+ public function getAddress($index)
+ {
+ if (!isset($this->addresses[$index])) {
+ return null;
+ }
+ return $this->addresses[$index];
+ }
+
+ /**
+ * Returns the name of the group
+ *
+ * @return string
+ */
+ public function getName()
+ {
+ return $this->value;
+ }
+}
diff --git a/hdz/vendor/zbateson/mail-mime-parser/src/Header/Part/AddressPart.php b/hdz/vendor/zbateson/mail-mime-parser/src/Header/Part/AddressPart.php
new file mode 100644
index 0000000..b423842
--- /dev/null
+++ b/hdz/vendor/zbateson/mail-mime-parser/src/Header/Part/AddressPart.php
@@ -0,0 +1,55 @@
+value = $this->convertEncoding(preg_replace('/\s+/', '', $email));
+ }
+
+ /**
+ * Returns the email address.
+ *
+ * @return string
+ */
+ public function getEmail()
+ {
+ return $this->value;
+ }
+}
diff --git a/hdz/vendor/zbateson/mail-mime-parser/src/Header/Part/CommentPart.php b/hdz/vendor/zbateson/mail-mime-parser/src/Header/Part/CommentPart.php
new file mode 100644
index 0000000..21fa94e
--- /dev/null
+++ b/hdz/vendor/zbateson/mail-mime-parser/src/Header/Part/CommentPart.php
@@ -0,0 +1,49 @@
+comment = $this->value;
+ $this->value = '';
+ $this->canIgnoreSpacesBefore = true;
+ $this->canIgnoreSpacesAfter = true;
+ }
+
+ /**
+ * Returns the comment's text.
+ *
+ * @return string
+ */
+ public function getComment()
+ {
+ return $this->comment;
+ }
+
+
+}
diff --git a/hdz/vendor/zbateson/mail-mime-parser/src/Header/Part/DatePart.php b/hdz/vendor/zbateson/mail-mime-parser/src/Header/Part/DatePart.php
new file mode 100644
index 0000000..3ca95da
--- /dev/null
+++ b/hdz/vendor/zbateson/mail-mime-parser/src/Header/Part/DatePart.php
@@ -0,0 +1,63 @@
+date = new DateTime($dateToken);
+ } catch (Exception $e) {
+ }
+ }
+
+ /**
+ * Returns a DateTime object or false if it can't be parsed.
+ *
+ * @return DateTime
+ */
+ public function getDateTime()
+ {
+ return $this->date;
+ }
+}
diff --git a/hdz/vendor/zbateson/mail-mime-parser/src/Header/Part/HeaderPart.php b/hdz/vendor/zbateson/mail-mime-parser/src/Header/Part/HeaderPart.php
new file mode 100644
index 0000000..1c376bd
--- /dev/null
+++ b/hdz/vendor/zbateson/mail-mime-parser/src/Header/Part/HeaderPart.php
@@ -0,0 +1,106 @@
+charsetConverter = $charsetConverter;
+ }
+
+ /**
+ * Returns the part's value.
+ *
+ * @return string the value of the part
+ */
+ public function getValue()
+ {
+ return $this->value;
+ }
+
+ /**
+ * Returns the value of the part (which is a string).
+ *
+ * @return string the value
+ */
+ public function __toString()
+ {
+ return $this->value;
+ }
+
+ /**
+ * Returns true if spaces before this part should be ignored. True is only
+ * returned for MimeLiterals if the part begins with a mime-encoded string,
+ * Tokens if the Token's value is a single space, and for CommentParts.
+ *
+ * @return bool
+ */
+ public function ignoreSpacesBefore()
+ {
+ return false;
+ }
+
+ /**
+ * Returns true if spaces after this part should be ignored. True is only
+ * returned for MimeLiterals if the part ends with a mime-encoded string
+ * Tokens if the Token's value is a single space, and for CommentParts.
+ *
+ * @return bool
+ */
+ public function ignoreSpacesAfter()
+ {
+ return false;
+ }
+
+ /**
+ * Ensures the encoding of the passed string is set to UTF-8.
+ *
+ * The method does nothing if the passed $from charset is UTF-8 already, or
+ * if $force is set to false and mb_check_encoding for $str returns true
+ * for 'UTF-8'.
+ *
+ * @param string $str
+ * @param string $from
+ * @param boolean $force
+ * @return string utf-8 string
+ */
+ protected function convertEncoding($str, $from = 'ISO-8859-1', $force = false)
+ {
+ if ($from !== 'UTF-8') {
+ // mime header part decoding will force it. This is necessary for
+ // UTF-7 because mb_check_encoding will return true
+ if ($force || !($this->charsetConverter->checkEncoding($str, 'UTF-8'))) {
+ return $this->charsetConverter->convert($str, $from, 'UTF-8');
+ }
+ }
+ return $str;
+ }
+}
diff --git a/hdz/vendor/zbateson/mail-mime-parser/src/Header/Part/HeaderPartFactory.php b/hdz/vendor/zbateson/mail-mime-parser/src/Header/Part/HeaderPartFactory.php
new file mode 100644
index 0000000..80e4eeb
--- /dev/null
+++ b/hdz/vendor/zbateson/mail-mime-parser/src/Header/Part/HeaderPartFactory.php
@@ -0,0 +1,189 @@
+charsetConverter = $charsetConverter;
+ }
+
+ /**
+ * Creates and returns a default HeaderPart for this factory, allowing
+ * subclass factories for specialized HeaderParts.
+ *
+ * The default implementation returns a new Token.
+ *
+ * @param string $value
+ * @return HeaderPart
+ */
+ public function newInstance($value)
+ {
+ return $this->newToken($value);
+ }
+
+ /**
+ * Initializes and returns a new Token.
+ *
+ * @param string $value
+ * @return \ZBateson\MailMimeParser\Header\Part\Token
+ */
+ public function newToken($value)
+ {
+ return new Token($this->charsetConverter, $value);
+ }
+
+ /**
+ * Instantiates and returns a SplitParameterToken with the given name.
+ *
+ * @param string $name
+ * @return SplitParameterToken
+ */
+ public function newSplitParameterToken($name)
+ {
+ return new SplitParameterToken($this->charsetConverter, $name);
+ }
+
+ /**
+ * Initializes and returns a new LiteralPart.
+ *
+ * @param string $value
+ * @return \ZBateson\MailMimeParser\Header\Part\LiteralPart
+ */
+ public function newLiteralPart($value)
+ {
+ return new LiteralPart($this->charsetConverter, $value);
+ }
+
+ /**
+ * Initializes and returns a new MimeLiteralPart.
+ *
+ * @param string $value
+ * @return \ZBateson\MailMimeParser\Header\Part\MimeLiteralPart
+ */
+ public function newMimeLiteralPart($value)
+ {
+ return new MimeLiteralPart($this->charsetConverter, $value);
+ }
+
+ /**
+ * Initializes and returns a new CommentPart.
+ *
+ * @param string $value
+ * @return \ZBateson\MailMimeParser\Header\Part\CommentPart
+ */
+ public function newCommentPart($value)
+ {
+ return new CommentPart($this->charsetConverter, $value);
+ }
+
+ /**
+ * Initializes and returns a new AddressPart.
+ *
+ * @param string $name
+ * @param string $email
+ * @return \ZBateson\MailMimeParser\Header\Part\AddressPart
+ */
+ public function newAddressPart($name, $email)
+ {
+ return new AddressPart($this->charsetConverter, $name, $email);
+ }
+
+ /**
+ * Initializes and returns a new AddressGroupPart
+ *
+ * @param array $addresses
+ * @param string $name
+ * @return \ZBateson\MailMimeParser\Header\Part\AddressGroupPart
+ */
+ public function newAddressGroupPart(array $addresses, $name = '')
+ {
+ return new AddressGroupPart($this->charsetConverter, $addresses, $name);
+ }
+
+ /**
+ * Initializes and returns a new DatePart
+ *
+ * @param string $value
+ * @return \ZBateson\MailMimeParser\Header\Part\DatePart
+ */
+ public function newDatePart($value)
+ {
+ return new DatePart($this->charsetConverter, $value);
+ }
+
+ /**
+ * Initializes and returns a new ParameterPart.
+ *
+ * @param string $name
+ * @param string $value
+ * @param string $language
+ * @return \ZBateson\MailMimeParser\Header\Part\ParameterPart
+ */
+ public function newParameterPart($name, $value, $language = null)
+ {
+ return new ParameterPart($this->charsetConverter, $name, $value, $language);
+ }
+
+ /**
+ * Initializes and returns a new ReceivedPart.
+ *
+ * @param string $name
+ * @param string $value
+ * @return \ZBateson\MailMimeParser\Header\Part\ReceivedPart
+ */
+ public function newReceivedPart($name, $value)
+ {
+ return new ReceivedPart($this->charsetConverter, $name, $value);
+ }
+
+ /**
+ * Initializes and returns a new ReceivedDomainPart.
+ *
+ * @param string $name
+ * @param string $value
+ * @param string $ehloName
+ * @param string $hostName
+ * @param string $hostAddress
+ * @return \ZBateson\MailMimeParser\Header\Part\ReceivedDomainPart
+ */
+ public function newReceivedDomainPart(
+ $name,
+ $value,
+ $ehloName = null,
+ $hostName = null,
+ $hostAddress = null
+ ) {
+ return new ReceivedDomainPart(
+ $this->charsetConverter,
+ $name,
+ $value,
+ $ehloName,
+ $hostName,
+ $hostAddress
+ );
+ }
+}
diff --git a/hdz/vendor/zbateson/mail-mime-parser/src/Header/Part/LiteralPart.php b/hdz/vendor/zbateson/mail-mime-parser/src/Header/Part/LiteralPart.php
new file mode 100644
index 0000000..aecef12
--- /dev/null
+++ b/hdz/vendor/zbateson/mail-mime-parser/src/Header/Part/LiteralPart.php
@@ -0,0 +1,34 @@
+value = $token;
+ if ($token !== null) {
+ $this->value = preg_replace('/\r|\n/', '', $this->convertEncoding($token));
+ }
+ }
+}
diff --git a/hdz/vendor/zbateson/mail-mime-parser/src/Header/Part/MimeLiteralPart.php b/hdz/vendor/zbateson/mail-mime-parser/src/Header/Part/MimeLiteralPart.php
new file mode 100644
index 0000000..7170f0e
--- /dev/null
+++ b/hdz/vendor/zbateson/mail-mime-parser/src/Header/Part/MimeLiteralPart.php
@@ -0,0 +1,199 @@
+value = $this->decodeMime($token);
+ // preg_match returns int
+ $pattern = self::MIME_PART_PATTERN;
+ $this->canIgnoreSpacesBefore = (bool) preg_match("/^\s*{$pattern}/", $token);
+ $this->canIgnoreSpacesAfter = (bool) preg_match("/{$pattern}\s*\$/", $token);
+ }
+
+ /**
+ * Finds and replaces mime parts with their values.
+ *
+ * The method splits the token value into an array on mime-part-patterns,
+ * either replacing a mime part with its value by calling iconv_mime_decode
+ * or converts the encoding on the text part by calling convertEncoding.
+ *
+ * @param string $value
+ * @return string
+ */
+ protected function decodeMime($value)
+ {
+ $pattern = self::MIME_PART_PATTERN;
+ // remove whitespace between two adjacent mime encoded parts
+ $value = preg_replace("/($pattern)\\s+(?=$pattern)/", '$1', $value);
+ // with PREG_SPLIT_DELIM_CAPTURE, matched and unmatched parts are returned
+ $aMimeParts = preg_split("/($pattern)/", $value, -1, PREG_SPLIT_DELIM_CAPTURE | PREG_SPLIT_NO_EMPTY);
+ $ret = '';
+ foreach ($aMimeParts as $entity) {
+ $ret .= $this->decodeSplitPart($entity);
+ }
+ return $ret;
+ }
+
+ /**
+ * Decodes a matched mime entity part into a string and returns it, after
+ * adding the string into the languages array.
+ *
+ * @param string[] $matches
+ * @return string
+ */
+ private function decodeMatchedEntity($matches)
+ {
+ $body = $matches[4];
+ if (strtoupper($matches[3]) === 'Q') {
+ $body = quoted_printable_decode(str_replace('_', '=20', $body));
+ } else {
+ $body = base64_decode($body);
+ }
+ $language = $matches[2];
+ $decoded = $this->convertEncoding($body, $matches[1], true);
+ $this->addToLanguage($decoded, $language);
+ return $decoded;
+ }
+
+ /**
+ * Decodes a single mime-encoded entity.
+ *
+ * Unfortunately, mb_decode_header fails for many charsets on PHP 5.4 and
+ * PHP 5.5 (even if they're listed as supported). iconv_mime_decode doesn't
+ * support all charsets.
+ *
+ * Parsing out the charset and body of the encoded entity seems to be the
+ * way to go to support the most charsets.
+ *
+ * @param string $entity
+ * @return string
+ */
+ private function decodeSplitPart($entity)
+ {
+ if (preg_match("/^=\?([A-Za-z\-_0-9]+)\*?([A-Za-z\-_0-9]+)?\?([QBqb])\?([^\?]+)\?=$/", $entity, $matches)) {
+ return $this->decodeMatchedEntity($matches);
+ }
+ $decoded = $this->convertEncoding($entity);
+ $this->addToLanguage($decoded);
+ return $decoded;
+ }
+
+ /**
+ * Returns true if spaces before this part should be ignored.
+ *
+ * Overridden to return $this->canIgnoreSpacesBefore which is setup in the
+ * constructor.
+ *
+ * @return bool
+ */
+ public function ignoreSpacesBefore()
+ {
+ return $this->canIgnoreSpacesBefore;
+ }
+
+ /**
+ * Returns true if spaces before this part should be ignored.
+ *
+ * Overridden to return $this->canIgnoreSpacesAfter which is setup in the
+ * constructor.
+ *
+ * @return bool
+ */
+ public function ignoreSpacesAfter()
+ {
+ return $this->canIgnoreSpacesAfter;
+ }
+
+ /**
+ * Adds the passed part into the languages array with the given language.
+ *
+ * @param string $part
+ * @param string|null $language
+ */
+ protected function addToLanguage($part, $language = null)
+ {
+ $this->languages[] = [
+ 'lang' => $language,
+ 'value' => $part
+ ];
+ }
+
+ /**
+ * Returns an array of parts mapped to languages in the header value, for
+ * instance the string:
+ *
+ * 'Hello and =?UTF-8*fr-be?Q?bonjour_?= =?UTF-8*it?Q?mi amici?=. Welcome!'
+ *
+ * Would be mapped in the returned array as follows:
+ *
+ * ```php
+ * [
+ * 0 => [ 'lang' => null, 'value' => 'Hello and ' ],
+ * 1 => [ 'lang' => 'fr-be', 'value' => 'bonjour ' ],
+ * 3 => [ 'lang' => 'it', 'value' => 'mi amici' ],
+ * 4 => [ 'lang' => null, 'value' => ' Welcome!' ]
+ * ]
+ * ```
+ *
+ * @return string[][]
+ */
+ public function getLanguageArray()
+ {
+ return $this->languages;
+ }
+}
diff --git a/hdz/vendor/zbateson/mail-mime-parser/src/Header/Part/MimeLiteralPartFactory.php b/hdz/vendor/zbateson/mail-mime-parser/src/Header/Part/MimeLiteralPartFactory.php
new file mode 100644
index 0000000..0bf89eb
--- /dev/null
+++ b/hdz/vendor/zbateson/mail-mime-parser/src/Header/Part/MimeLiteralPartFactory.php
@@ -0,0 +1,27 @@
+newMimeLiteralPart($value);
+ }
+}
diff --git a/hdz/vendor/zbateson/mail-mime-parser/src/Header/Part/ParameterPart.php b/hdz/vendor/zbateson/mail-mime-parser/src/Header/Part/ParameterPart.php
new file mode 100644
index 0000000..00b5842
--- /dev/null
+++ b/hdz/vendor/zbateson/mail-mime-parser/src/Header/Part/ParameterPart.php
@@ -0,0 +1,73 @@
+name = $name;
+ $this->value = $value;
+ $this->language = $language;
+ } else {
+ parent::__construct($charsetConverter, trim($value));
+ $this->name = $this->decodeMime(trim($name));
+ }
+ }
+
+ /**
+ * Returns the name of the parameter.
+ *
+ * @return string
+ */
+ public function getName()
+ {
+ return $this->name;
+ }
+
+ /**
+ * Returns the RFC-1766 (or subset) language tag, if the parameter is a
+ * split RFC-2231 part with a language tag set.
+ *
+ * @return string
+ */
+ public function getLanguage()
+ {
+ return $this->language;
+ }
+}
diff --git a/hdz/vendor/zbateson/mail-mime-parser/src/Header/Part/ReceivedDomainPart.php b/hdz/vendor/zbateson/mail-mime-parser/src/Header/Part/ReceivedDomainPart.php
new file mode 100644
index 0000000..e0ab5b8
--- /dev/null
+++ b/hdz/vendor/zbateson/mail-mime-parser/src/Header/Part/ReceivedDomainPart.php
@@ -0,0 +1,98 @@
+ehloName = $ehloName;
+ $this->hostname = $hostname;
+ $this->address = $address;
+ }
+
+ /**
+ * Returns the name used to identify the server in the first part of the
+ * extended-domain line. Note that this is not necessarily the name used in
+ * the EHLO line to an SMTP server, since implementations differ so much,
+ * not much can be guaranteed except the position it was parsed in.
+ *
+ * @return string
+ */
+ public function getEhloName()
+ {
+ return $this->ehloName;
+ }
+
+ /**
+ * Returns the hostname of the server, or whatever string in the hostname
+ * position when parsing (but never an address).
+ *
+ * @return string
+ */
+ public function getHostname()
+ {
+ return $this->hostname;
+ }
+
+ /**
+ * Returns the address of the server, or whatever string that looks like an
+ * address in the address position when parsing (but never a hostname).
+ *
+ * @return string
+ */
+ public function getAddress()
+ {
+ return $this->address;
+ }
+}
diff --git a/hdz/vendor/zbateson/mail-mime-parser/src/Header/Part/ReceivedPart.php b/hdz/vendor/zbateson/mail-mime-parser/src/Header/Part/ReceivedPart.php
new file mode 100644
index 0000000..52a9fb8
--- /dev/null
+++ b/hdz/vendor/zbateson/mail-mime-parser/src/Header/Part/ReceivedPart.php
@@ -0,0 +1,36 @@
+name = trim($name);
+ $this->value = trim($value);
+ }
+}
diff --git a/hdz/vendor/zbateson/mail-mime-parser/src/Header/Part/SplitParameterToken.php b/hdz/vendor/zbateson/mail-mime-parser/src/Header/Part/SplitParameterToken.php
new file mode 100644
index 0000000..44c1bf9
--- /dev/null
+++ b/hdz/vendor/zbateson/mail-mime-parser/src/Header/Part/SplitParameterToken.php
@@ -0,0 +1,187 @@
+name = trim($name);
+ }
+
+ /**
+ * Extracts charset and language from an encoded value, setting them on the
+ * current object if $index is 0 and adds the value part to the encodedParts
+ * array.
+ *
+ * @param string $value
+ * @param int $index
+ */
+ protected function extractMetaInformationAndValue($value, $index)
+ {
+ if (preg_match('~^([^\']*)\'([^\']*)\'(.*)$~', $value, $matches)) {
+ if ($index === 0) {
+ $this->charset = (!empty($matches[1])) ? $matches[1] : $this->charset;
+ $this->language = (!empty($matches[2])) ? $matches[2] : $this->language;
+ }
+ $value = $matches[3];
+ }
+ $this->encodedParts[$index] = $value;
+ }
+
+ /**
+ * Adds the passed part to the running array of values.
+ *
+ * If $isEncoded is true, language and charset info is extracted from the
+ * value, and the value is decoded before returning in getValue.
+ *
+ * The value of the parameter is sorted based on the passed $index
+ * arguments when adding before concatenating when re-constructing the
+ * value.
+ *
+ * @param string $value
+ * @param boolean $isEncoded
+ * @param int $index
+ */
+ public function addPart($value, $isEncoded, $index)
+ {
+ if (empty($index)) {
+ $index = 0;
+ }
+ if ($isEncoded) {
+ $this->extractMetaInformationAndValue($value, $index);
+ } else {
+ $this->literalParts[$index] = $this->convertEncoding($value);
+ }
+ }
+
+ /**
+ * Traverses $this->encodedParts until a non-sequential key is found, or the
+ * end of the array is found.
+ *
+ * This allows encoded parts of a split parameter to be split anywhere and
+ * reconstructed.
+ *
+ * The returned string is converted to UTF-8 before being returned.
+ *
+ * @return string
+ */
+ private function getNextEncodedValue()
+ {
+ $cur = current($this->encodedParts);
+ $key = key($this->encodedParts);
+ $running = '';
+ while ($cur !== false) {
+ $running .= $cur;
+ $cur = next($this->encodedParts);
+ $nKey = key($this->encodedParts);
+ if ($nKey !== $key + 1) {
+ break;
+ }
+ $key = $nKey;
+ }
+ return $this->convertEncoding(
+ rawurldecode($running),
+ $this->charset,
+ true
+ );
+ }
+
+ /**
+ * Reconstructs the value of the split parameter into a single UTF-8 string
+ * and returns it.
+ *
+ * @return string
+ */
+ public function getValue()
+ {
+ $parts = $this->literalParts;
+
+ reset($this->encodedParts);
+ ksort($this->encodedParts);
+ while (current($this->encodedParts) !== false) {
+ $parts[key($this->encodedParts)] = $this->getNextEncodedValue();
+ }
+
+ ksort($parts);
+ return array_reduce(
+ $parts,
+ function ($carry, $item) {
+ return $carry . $item;
+ },
+ ''
+ );
+ }
+
+ /**
+ * Returns the name of the parameter.
+ *
+ * @return string
+ */
+ public function getName()
+ {
+ return $this->name;
+ }
+
+ /**
+ * Returns the language of the parameter if set, or null if not.
+ *
+ * @return string
+ */
+ public function getLanguage()
+ {
+ return $this->language;
+ }
+}
diff --git a/hdz/vendor/zbateson/mail-mime-parser/src/Header/Part/Token.php b/hdz/vendor/zbateson/mail-mime-parser/src/Header/Part/Token.php
new file mode 100644
index 0000000..a541990
--- /dev/null
+++ b/hdz/vendor/zbateson/mail-mime-parser/src/Header/Part/Token.php
@@ -0,0 +1,66 @@
+value = $value;
+ }
+
+ /**
+ * Returns true if the value of the token is equal to a single space.
+ *
+ * @return bool
+ */
+ public function isSpace()
+ {
+ return (preg_match('/^\s+$/', $this->value) === 1);
+ }
+
+ /**
+ * Returns true if the value is a space.
+ *
+ * @return bool
+ */
+ public function ignoreSpacesBefore()
+ {
+ return $this->isSpace();
+ }
+
+ /**
+ * Returns true if the value is a space.
+ *
+ * @return bool
+ */
+ public function ignoreSpacesAfter()
+ {
+ return $this->isSpace();
+ }
+}
diff --git a/hdz/vendor/zbateson/mail-mime-parser/src/Header/ReceivedHeader.php b/hdz/vendor/zbateson/mail-mime-parser/src/Header/ReceivedHeader.php
new file mode 100644
index 0000000..3a4881d
--- /dev/null
+++ b/hdz/vendor/zbateson/mail-mime-parser/src/Header/ReceivedHeader.php
@@ -0,0 +1,247 @@
+hasParameter('from') ``` or
+ * ``` $header->hasParameter('id') ```. The value of the part can be obtained
+ * by calling {@see ReceivedHeader::getValueFor()}, for example
+ * ``` $header->getValueFor('with'); ```.
+ *
+ * Additional parsing is performed on the "FROM" and "BY" parts of a received
+ * header in an attempt to extract the self-identified name of the server, its
+ * hostname, and its address (depending on what's included). These can be
+ * accessed directly from the ReceivedHeader object by calling one of the
+ * following methods:
+ *
+ * o {@see ReceivedHeader::getFromName()} -- the name portion of the FROM part
+ * o {@see ReceivedHeader::getFromHostname()} -- the hostname of the FROM part
+ * o {@see ReceivedHeader::getFromAddress()} -- the adddress portion of the FROM
+ * part
+ * o {@see ReceivedHeader::getByName()} -- same as getFromName, but for the BY
+ * part, and etc... below
+ * o {@see ReceivedHeader::getByHostname()}
+ * o {@see ReceivedHeader::getByAddress()}
+ *
+ * The parsed parts of the FROM and BY parts are determined as follows:
+ *
+ * o Anything outside and before a parenthesized expression is considered "the
+ * name", for example "FROM AlainDeBotton", "AlainDeBotton" would be the name,
+ * but also if the name is an address, but exists outside the parenthesized
+ * expression, it's still considered "the name". For example:
+ * "From [1.2.3.4]", getFromName would return "[1.2.3.4]".
+ * o A parenthesized expression MUST match what looks like either a domain name
+ * on its own, or a domain name and an address. Otherwise the parenthesized
+ * expression is considered a comment, and not parsed into hostname and
+ * address. The rules are defined loosely because many implementations differ
+ * in how strictly they follow the standard. For a domain, it's enough that
+ * the expression starts with any alphanumeric character and contains at least
+ * one '.', followed by any number of '.', '-' and alphanumeric characters.
+ * The address portion must be surrounded in square brackets, and contain any
+ * sequence of '.', ':', numbers, and characters 'a' through 'f'. In addition
+ * the string 'ipv6' may start the expression (for instance, '[ipv6:::1]'
+ * would be valid). A port number may also be considered valid as part of the
+ * address, for example: [1.2.3.4:3231]. No additional validation on the
+ * address is done, and so an invalid address such as '....' could be
+ * returned, so users using the 'address' header are encouraged to validate it
+ * before using it. The square brackets are parsed out of the returned
+ * address, so the value returned by getFromAddress() would be "2.2.2.2", not
+ * "[2.2.2.2]".
+ *
+ * The date/time stamp can be accessed as a DateTime object by calling
+ * {@see ReceivedHeader::getDateTime()}.
+ *
+ * Parsed comments can be accessed by calling {@see
+ * ReceivedHeader::getComments()}. Some implementations may include connection
+ * encryption information or other details in non-standardized comments.
+ *
+ * @author Zaahid Bateson
+ */
+class ReceivedHeader extends ParameterHeader
+{
+ /**
+ * @var string[] an array of comments in the header.
+ */
+ protected $comments = [];
+
+ /**
+ * @var DateTime the date/time stamp in the header.
+ */
+ protected $date;
+
+ /**
+ * Returns a ReceivedConsumer.
+ *
+ * @param ConsumerService $consumerService
+ * @return \ZBateson\MailMimeParser\Header\Consumer\AbstractConsumer
+ */
+ protected function getConsumer(ConsumerService $consumerService)
+ {
+ return $consumerService->getReceivedConsumer();
+ }
+
+ /**
+ * Overridden to assign comments to $this->comments, and the DateTime to
+ * $this->date.
+ *
+ * @param AbstractConsumer $consumer
+ */
+ protected function setParseHeaderValue(AbstractConsumer $consumer)
+ {
+ parent::setParseHeaderValue($consumer);
+ foreach ($this->parts as $part) {
+ if ($part instanceof CommentPart) {
+ $this->comments[] = $part->getComment();
+ } elseif ($part instanceof DatePart) {
+ $this->date = $part->getDateTime();
+ }
+ }
+ }
+
+ /**
+ * Returns the raw, unparsed header value, same as {@see
+ * ReceivedHeader::getRawValue()}.
+ *
+ * @return string
+ */
+ public function getValue()
+ {
+ return $this->rawValue;
+ }
+
+ /**
+ * Returns the name identified in the FROM part of the header.
+ *
+ * The returned value may either be a name or an address in the form
+ * "[1.2.3.4]". Validation is not performed on this value, and so whatever
+ * exists in this position is returned -- be it contains spaces, or invalid
+ * characters, etc...
+ *
+ * @return string
+ */
+ public function getFromName()
+ {
+ return (isset($this->parameters['from'])) ?
+ $this->parameters['from']->getEhloName() : null;
+ }
+
+ /**
+ * Returns the hostname part of a parenthesized FROM part.
+ *
+ * For example, "FROM name (host.name)" would return the string "host.name".
+ * Validation of the hostname is not performed, and the returned value may
+ * not be valid. More details on how the value is parsed and extracted can
+ * be found in the class description for {@see ReceivedHeader}.
+ *
+ * @return string
+ */
+ public function getFromHostname()
+ {
+ return (isset($this->parameters['from'])) ?
+ $this->parameters['from']->getHostname() : null;
+ }
+
+ /**
+ * Returns the address part of a parenthesized FROM part.
+ *
+ * For example, "FROM name ([1.2.3.4])" would return the string "1.2.3.4".
+ * Validation of the address is not performed, and the returned value may
+ * not be valid. More details on how the value is parsed and extracted can
+ * be found in the class description for {@see ReceivedHeader}.
+ *
+ * @return string
+ */
+ public function getFromAddress()
+ {
+ return (isset($this->parameters['from'])) ?
+ $this->parameters['from']->getAddress() : null;
+ }
+
+ /**
+ * Returns the name identified in the BY part of the header.
+ *
+ * The returned value may either be a name or an address in the form
+ * "[1.2.3.4]". Validation is not performed on this value, and so whatever
+ * exists in this position is returned -- be it contains spaces, or invalid
+ * characters, etc...
+ *
+ * @return string
+ */
+ public function getByName()
+ {
+ return (isset($this->parameters['by'])) ?
+ $this->parameters['by']->getEhloName() : null;
+ }
+
+ /**
+ * Returns the hostname part of a parenthesized BY part.
+ *
+ * For example, "BY name (host.name)" would return the string "host.name".
+ * Validation of the hostname is not performed, and the returned value may
+ * not be valid. More details on how the value is parsed and extracted can
+ * be found in the class description for {@see ReceivedHeader}.
+ *
+ * @return string
+ */
+ public function getByHostname()
+ {
+ return (isset($this->parameters['by'])) ?
+ $this->parameters['by']->getHostname() : null;
+ }
+
+ /**
+ * Returns the address part of a parenthesized BY part.
+ *
+ * For example, "BY name ([1.2.3.4])" would return the string "1.2.3.4".
+ * Validation of the address is not performed, and the returned value may
+ * not be valid. More details on how the value is parsed and extracted can
+ * be found in the class description for {@see ReceivedHeader}.
+ *
+ * @return string
+ */
+ public function getByAddress()
+ {
+ return (isset($this->parameters['by'])) ?
+ $this->parameters['by']->getAddress() : null;
+ }
+
+ /**
+ * Returns an array of comments parsed from the header. If there are no
+ * comments in the header, an empty array is returned.
+ *
+ * @return string[]
+ */
+ public function getComments()
+ {
+ return $this->comments;
+ }
+
+ /**
+ * Returns the date/time stamp for the received header.
+ *
+ * @return \DateTime
+ */
+ public function getDateTime()
+ {
+ return $this->date;
+ }
+}
diff --git a/hdz/vendor/zbateson/mail-mime-parser/src/Header/SubjectHeader.php b/hdz/vendor/zbateson/mail-mime-parser/src/Header/SubjectHeader.php
new file mode 100644
index 0000000..3b43b64
--- /dev/null
+++ b/hdz/vendor/zbateson/mail-mime-parser/src/Header/SubjectHeader.php
@@ -0,0 +1,28 @@
+getSubjectConsumer();
+ }
+}
diff --git a/hdz/vendor/zbateson/mail-mime-parser/src/MailMimeParser.php b/hdz/vendor/zbateson/mail-mime-parser/src/MailMimeParser.php
new file mode 100644
index 0000000..f05d3ed
--- /dev/null
+++ b/hdz/vendor/zbateson/mail-mime-parser/src/MailMimeParser.php
@@ -0,0 +1,77 @@
+parse($handle);
+ * fclose($handle);
+ *
+ * @author Zaahid Bateson
+ */
+class MailMimeParser
+{
+ /**
+ * @var string the default charset used to encode strings (or string content
+ * like streams) returned by MailMimeParser (for e.g. the string
+ * returned by calling $message->getTextContent()).
+ */
+ const DEFAULT_CHARSET = 'UTF-8';
+
+ /**
+ * @var \ZBateson\MailMimeParser\Container dependency injection container
+ */
+ protected $di;
+
+ /**
+ * Sets up the parser.
+ *
+ * @param Container $di pass a Container object to use it for
+ * initialization.
+ */
+ public function __construct(Container $di = null)
+ {
+ if ($di === null) {
+ $di = new Container();
+ }
+ $this->di = $di;
+ }
+
+ /**
+ * Parses the passed stream handle into a ZBateson\MailMimeParser\Message
+ * object and returns it.
+ *
+ * Internally, the message is first copied to a temp stream (with php://temp
+ * which may keep it in memory or write it to disk) and its stream is used.
+ * That way if the message is too large to hold in memory it can be written
+ * to a temporary file if need be.
+ *
+ * @param resource|string $handleOrString the resource handle to the input
+ * stream of the mime message, or a string containing a mime message
+ * @return \ZBateson\MailMimeParser\Message
+ */
+ public function parse($handleOrString)
+ {
+ $stream = Psr7\stream_for($handleOrString);
+ $copy = Psr7\stream_for(fopen('php://temp', 'r+'));
+
+ Psr7\copy_to_stream($stream, $copy);
+ $copy->rewind();
+
+ // don't close it when $stream gets destroyed
+ $stream->detach();
+ $parser = $this->di->newMessageParser();
+ return $parser->parse($copy);
+ }
+}
diff --git a/hdz/vendor/zbateson/mail-mime-parser/src/Message.php b/hdz/vendor/zbateson/mail-mime-parser/src/Message.php
new file mode 100644
index 0000000..af13aee
--- /dev/null
+++ b/hdz/vendor/zbateson/mail-mime-parser/src/Message.php
@@ -0,0 +1,559 @@
+messageHelperService = $messageHelperService;
+ }
+
+ /**
+ * Convenience method to parse a handle or string into a Message without
+ * requiring including MailMimeParser, instantiating it, and calling parse.
+ *
+ * @param resource|string $handleOrString the resource handle to the input
+ * stream of the mime message, or a string containing a mime message
+ * @return Message
+ */
+ public static function from($handleOrString)
+ {
+ $mmp = new MailMimeParser();
+ return $mmp->parse($handleOrString);
+ }
+
+ /**
+ * Returns the text/plain part at the given index (or null if not found.)
+ *
+ * @param int $index
+ * @return MessagePart
+ */
+ public function getTextPart($index = 0)
+ {
+ return $this->getPart(
+ $index,
+ $this->partFilterFactory->newFilterFromInlineContentType('text/plain')
+ );
+ }
+
+ /**
+ * Returns the number of text/plain parts in this message.
+ *
+ * @return int
+ */
+ public function getTextPartCount()
+ {
+ return $this->getPartCount(
+ $this->partFilterFactory->newFilterFromInlineContentType('text/plain')
+ );
+ }
+
+ /**
+ * Returns the text/html part at the given index (or null if not found.)
+ *
+ * @param int $index
+ * @return MessagePart
+ */
+ public function getHtmlPart($index = 0)
+ {
+ return $this->getPart(
+ $index,
+ $this->partFilterFactory->newFilterFromInlineContentType('text/html')
+ );
+ }
+
+ /**
+ * Returns the number of text/html parts in this message.
+ *
+ * @return int
+ */
+ public function getHtmlPartCount()
+ {
+ return $this->getPartCount(
+ $this->partFilterFactory->newFilterFromInlineContentType('text/html')
+ );
+ }
+
+ /**
+ * Returns the attachment part at the given 0-based index, or null if none
+ * is set.
+ *
+ * @param int $index
+ * @return MessagePart
+ */
+ public function getAttachmentPart($index)
+ {
+ $attachments = $this->getAllAttachmentParts();
+ if (!isset($attachments[$index])) {
+ return null;
+ }
+ return $attachments[$index];
+ }
+
+ /**
+ * Returns all attachment parts.
+ *
+ * "Attachments" are any non-multipart, non-signature and any text or html
+ * html part witha Content-Disposition set to 'attachment'.
+ *
+ * @return MessagePart[]
+ */
+ public function getAllAttachmentParts()
+ {
+ $parts = $this->getAllParts(
+ $this->partFilterFactory->newFilterFromArray([
+ 'multipart' => PartFilter::FILTER_EXCLUDE
+ ])
+ );
+ return array_values(array_filter(
+ $parts,
+ function ($part) {
+ return !(
+ $part->isTextPart()
+ && $part->getContentDisposition() === 'inline'
+ );
+ }
+ ));
+ }
+
+ /**
+ * Returns the number of attachments available.
+ *
+ * @return int
+ */
+ public function getAttachmentCount()
+ {
+ return count($this->getAllAttachmentParts());
+ }
+
+ /**
+ * Returns a Psr7 Stream for the 'inline' text/plain content at the passed
+ * $index, or null if unavailable.
+ *
+ * @param int $index
+ * @param string $charset
+ * @return StreamInterface
+ */
+ public function getTextStream($index = 0, $charset = MailMimeParser::DEFAULT_CHARSET)
+ {
+ $textPart = $this->getTextPart($index);
+ if ($textPart !== null) {
+ return $textPart->getContentStream($charset);
+ }
+ return null;
+ }
+
+ /**
+ * Returns a resource handle for the 'inline' text/plain content at the
+ * passed $index, or null if unavailable.
+ *
+ * Note: this method should *not* be used and has been deprecated. Instead,
+ * use Psr7 streams with getTextStream. Multibyte chars will not be read
+ * correctly with getTextResourceHandle/fread.
+ *
+ * @param int $index
+ * @param string $charset
+ * @deprecated since version 1.2.1
+ * @return resource
+ */
+ public function getTextResourceHandle($index = 0, $charset = MailMimeParser::DEFAULT_CHARSET)
+ {
+ trigger_error("getTextResourceHandle is deprecated since version 1.2.1", E_USER_DEPRECATED);
+ $textPart = $this->getTextPart($index);
+ if ($textPart !== null) {
+ return $textPart->getContentResourceHandle($charset);
+ }
+ return null;
+ }
+
+ /**
+ * Returns the content of the inline text/plain part at the given index.
+ *
+ * Reads the entire stream content into a string and returns it. Returns
+ * null if the message doesn't have an inline text part.
+ *
+ * @param int $index
+ * @param string $charset
+ * @return string
+ */
+ public function getTextContent($index = 0, $charset = MailMimeParser::DEFAULT_CHARSET)
+ {
+ $part = $this->getTextPart($index);
+ if ($part !== null) {
+ return $part->getContent($charset);
+ }
+ return null;
+ }
+
+ /**
+ * Returns a Psr7 Stream for the 'inline' text/html content at the passed
+ * $index, or null if unavailable.
+ *
+ * @param int $index
+ * @param string $charset
+ * @return StreamInterface
+ */
+ public function getHtmlStream($index = 0, $charset = MailMimeParser::DEFAULT_CHARSET)
+ {
+ $htmlPart = $this->getHtmlPart($index);
+ if ($htmlPart !== null) {
+ return $htmlPart->getContentStream($charset);
+ }
+ return null;
+ }
+
+ /**
+ * Returns a resource handle for the 'inline' text/html content at the
+ * passed $index, or null if unavailable.
+ *
+ * Note: this method should *not* be used and has been deprecated. Instead,
+ * use Psr7 streams with getHtmlStream. Multibyte chars will not be read
+ * correctly with getHtmlResourceHandle/fread.
+ *
+ * @param int $index
+ * @param string $charset
+ * @deprecated since version 1.2.1
+ * @return resource
+ */
+ public function getHtmlResourceHandle($index = 0, $charset = MailMimeParser::DEFAULT_CHARSET)
+ {
+ trigger_error("getHtmlResourceHandle is deprecated since version 1.2.1", E_USER_DEPRECATED);
+ $htmlPart = $this->getHtmlPart($index);
+ if ($htmlPart !== null) {
+ return $htmlPart->getContentResourceHandle($charset);
+ }
+ return null;
+ }
+
+ /**
+ * Returns the content of the inline text/html part at the given index.
+ *
+ * Reads the entire stream content into a string and returns it. Returns
+ * null if the message doesn't have an inline html part.
+ *
+ * @param int $index
+ * @param string $charset
+ * @return string
+ */
+ public function getHtmlContent($index = 0, $charset = MailMimeParser::DEFAULT_CHARSET)
+ {
+ $part = $this->getHtmlPart($index);
+ if ($part !== null) {
+ return $part->getContent($charset);
+ }
+ return null;
+ }
+
+ /**
+ * Returns true if either a Content-Type or Mime-Version header are defined
+ * in this Message.
+ *
+ * @return bool
+ */
+ public function isMime()
+ {
+ $contentType = $this->getHeaderValue('Content-Type');
+ $mimeVersion = $this->getHeaderValue('Mime-Version');
+ return ($contentType !== null || $mimeVersion !== null);
+ }
+
+ /**
+ * Sets the text/plain part of the message to the passed $stringOrHandle,
+ * either creating a new part if one doesn't exist for text/plain, or
+ * assigning the value of $stringOrHandle to an existing text/plain part.
+ *
+ * The optional $charset parameter is the charset for saving to.
+ * $stringOrHandle is expected to be in UTF-8 regardless of the target
+ * charset.
+ *
+ * @param string|resource|StreamInterface $resource
+ * @param string $charset
+ */
+ public function setTextPart($resource, $charset = 'UTF-8')
+ {
+ $this->messageHelperService
+ ->getMultipartHelper()
+ ->setContentPartForMimeType(
+ $this, 'text/plain', $resource, $charset
+ );
+ }
+
+ /**
+ * Sets the text/html part of the message to the passed $stringOrHandle,
+ * either creating a new part if one doesn't exist for text/html, or
+ * assigning the value of $stringOrHandle to an existing text/html part.
+ *
+ * The optional $charset parameter is the charset for saving to.
+ * $stringOrHandle is expected to be in UTF-8 regardless of the target
+ * charset.
+ *
+ * @param string|resource|StreamInterface $resource
+ * @param string $charset
+ */
+ public function setHtmlPart($resource, $charset = 'UTF-8')
+ {
+ $this->messageHelperService
+ ->getMultipartHelper()
+ ->setContentPartForMimeType(
+ $this, 'text/html', $resource, $charset
+ );
+ }
+
+ /**
+ * Removes the text/plain part of the message at the passed index if one
+ * exists. Returns true on success.
+ *
+ * @param int $index
+ * @return bool true on success
+ */
+ public function removeTextPart($index = 0)
+ {
+ return $this->messageHelperService
+ ->getMultipartHelper()
+ ->removePartByMimeType(
+ $this, 'text/plain', $index
+ );
+ }
+
+ /**
+ * Removes all text/plain inline parts in this message, optionally keeping
+ * other inline parts as attachments on the main message (defaults to
+ * keeping them).
+ *
+ * @param bool $keepOtherPartsAsAttachments
+ * @return bool true on success
+ */
+ public function removeAllTextParts($keepOtherPartsAsAttachments = true)
+ {
+ return $this->messageHelperService
+ ->getMultipartHelper()
+ ->removeAllContentPartsByMimeType(
+ $this, 'text/plain', $keepOtherPartsAsAttachments
+ );
+ }
+
+ /**
+ * Removes the html part of the message if one exists. Returns true on
+ * success.
+ *
+ * @param int $index
+ * @return bool true on success
+ */
+ public function removeHtmlPart($index = 0)
+ {
+ return $this->messageHelperService
+ ->getMultipartHelper()
+ ->removePartByMimeType(
+ $this, 'text/html', $index
+ );
+ }
+
+ /**
+ * Removes all text/html inline parts in this message, optionally keeping
+ * other inline parts as attachments on the main message (defaults to
+ * keeping them).
+ *
+ * @param bool $keepOtherPartsAsAttachments
+ * @return bool true on success
+ */
+ public function removeAllHtmlParts($keepOtherPartsAsAttachments = true)
+ {
+ return $this->messageHelperService
+ ->getMultipartHelper()
+ ->removeAllContentPartsByMimeType(
+ $this, 'text/html', $keepOtherPartsAsAttachments
+ );
+ }
+
+ /**
+ * Adds an attachment part for the passed raw data string or handle and
+ * given parameters.
+ *
+ * @param string|resource|StreamInterface $resource
+ * @param string $mimeType
+ * @param string $filename
+ * @param string $disposition
+ * @param string $encoding defaults to 'base64', only applied for a mime
+ * email
+ */
+ public function addAttachmentPart($resource, $mimeType, $filename = null, $disposition = 'attachment', $encoding = 'base64')
+ {
+ $this->messageHelperService
+ ->getMultipartHelper()
+ ->createAndAddPartForAttachment($this, $resource, $mimeType, $disposition, $filename, $encoding);
+ }
+
+ /**
+ * Adds an attachment part using the passed file.
+ *
+ * Essentially creates a file stream and uses it.
+ *
+ * @param string $filePath
+ * @param string $mimeType
+ * @param string $filename
+ * @param string $disposition
+ */
+ public function addAttachmentPartFromFile($filePath, $mimeType, $filename = null, $disposition = 'attachment', $encoding = 'base64')
+ {
+ $handle = Psr7\stream_for(fopen($filePath, 'r'));
+ if ($filename === null) {
+ $filename = basename($filePath);
+ }
+ $this->addAttachmentPart($handle, $mimeType, $filename, $disposition, $encoding);
+ }
+
+ /**
+ * Removes the attachment with the given index
+ *
+ * @param int $index
+ */
+ public function removeAttachmentPart($index)
+ {
+ $part = $this->getAttachmentPart($index);
+ $this->removePart($part);
+ }
+
+ /**
+ * Returns a stream that can be used to read the content part of a signed
+ * message, which can be used to sign an email or verify a signature.
+ *
+ * The method simply returns the stream for the first child. No
+ * verification of whether the message is in fact a signed message is
+ * performed.
+ *
+ * Note that unlike getSignedMessageAsString, getSignedMessageStream doesn't
+ * replace new lines.
+ *
+ * @return StreamInterface or null if the message doesn't have any children
+ */
+ public function getSignedMessageStream()
+ {
+ return $this
+ ->messageHelperService
+ ->getPrivacyHelper()
+ ->getSignedMessageStream($this);
+ }
+
+ /**
+ * Returns a string containing the entire body of a signed message for
+ * verification or calculating a signature.
+ *
+ * Non-CRLF new lines are replaced to always be CRLF.
+ *
+ * @return string or null if the message doesn't have any children
+ */
+ public function getSignedMessageAsString()
+ {
+ return $this
+ ->messageHelperService
+ ->getPrivacyHelper()
+ ->getSignedMessageAsString($this);
+ }
+
+ /**
+ * Returns the signature part of a multipart/signed message or null.
+ *
+ * The signature part is determined to always be the 2nd child of a
+ * multipart/signed message, the first being the 'body'.
+ *
+ * Using the 'protocol' parameter of the Content-Type header is unreliable
+ * in some instances (for instance a difference of x-pgp-signature versus
+ * pgp-signature).
+ *
+ * @return MimePart
+ */
+ public function getSignaturePart()
+ {
+ return $this
+ ->messageHelperService
+ ->getPrivacyHelper()
+ ->getSignaturePart($this);
+ }
+
+ /**
+ * Turns the message into a multipart/signed message, moving the actual
+ * message into a child part, sets the content-type of the main message to
+ * multipart/signed and adds an empty signature part as well.
+ *
+ * After calling setAsMultipartSigned, call getSignedMessageAsString to
+ * return a
+ *
+ * @param string $micalg The Message Integrity Check algorithm being used
+ * @param string $protocol The mime-type of the signature body
+ */
+ public function setAsMultipartSigned($micalg, $protocol)
+ {
+ $this
+ ->messageHelperService
+ ->getPrivacyHelper()
+ ->setMessageAsMultipartSigned($this, $micalg, $protocol);
+ }
+
+ /**
+ * Sets the signature body of the message to the passed $body for a
+ * multipart/signed message.
+ *
+ * @param string $body
+ */
+ public function setSignature($body)
+ {
+ $this->messageHelperService->getPrivacyHelper()
+ ->setSignature($this, $body);
+ }
+}
diff --git a/hdz/vendor/zbateson/mail-mime-parser/src/Message/Helper/AbstractHelper.php b/hdz/vendor/zbateson/mail-mime-parser/src/Message/Helper/AbstractHelper.php
new file mode 100644
index 0000000..2af24b5
--- /dev/null
+++ b/hdz/vendor/zbateson/mail-mime-parser/src/Message/Helper/AbstractHelper.php
@@ -0,0 +1,51 @@
+mimePartFactory = $mimePartFactory;
+ $this->uuEncodedPartFactory = $uuEncodedPartFactory;
+ $this->partBuilderFactory = $partBuilderFactory;
+ }
+}
diff --git a/hdz/vendor/zbateson/mail-mime-parser/src/Message/Helper/GenericHelper.php b/hdz/vendor/zbateson/mail-mime-parser/src/Message/Helper/GenericHelper.php
new file mode 100644
index 0000000..98d3e53
--- /dev/null
+++ b/hdz/vendor/zbateson/mail-mime-parser/src/Message/Helper/GenericHelper.php
@@ -0,0 +1,159 @@
+getHeader($header);
+ $set = ($fromHeader !== null) ? $fromHeader->getRawValue() : $default;
+ if ($set !== null) {
+ $to->setRawHeader($header, $set);
+ }
+ }
+
+ /**
+ * Removes Content-* headers (permanent ones as defined in
+ * https://tools.ietf.org/html/rfc4021#section-2.2) from the passed part,
+ * then detaches its content stream.
+ *
+ * @param ParentHeaderPart $part
+ */
+ public function removeContentHeadersAndContent(ParentHeaderPart $part)
+ {
+ foreach (self::$contentHeaders as $header) {
+ $part->removeHeader($header);
+ }
+ $part->detachContentStream();
+ }
+
+ /**
+ * Copies Content-* headers (permanent ones as defined in
+ * https://tools.ietf.org/html/rfc4021#section-2.2)
+ * from the $from header into the $to header. If the Content-Type header
+ * isn't defined in $from, defaults to text/plain with utf-8 and
+ * quoted-printable.
+ *
+ * @param ParentHeaderPart $from
+ * @param ParentHeaderPart $to
+ * @param bool $move
+ */
+ public function copyContentHeadersAndContent(ParentHeaderPart $from, ParentHeaderPart $to, $move = false)
+ {
+ $this->copyHeader($from, $to, 'Content-Type', 'text/plain; charset=utf-8');
+ if ($from->getHeader('Content-Type') === null) {
+ $this->copyHeader($from, $to, 'Content-Transfer-Encoding', 'quoted-printable');
+ } else {
+ $this->copyHeader($from, $to, 'Content-Transfer-Encoding');
+ }
+ $rem = array_diff(self::$contentHeaders, [ 'Content-Type', 'Content-Transfer-Encoding']);
+ foreach ($rem as $header) {
+ $this->copyHeader($from, $to, $header);
+ }
+ if ($from->hasContent()) {
+ $to->attachContentStream($from->getContentStream(), MailMimeParser::DEFAULT_CHARSET);
+ }
+ if ($move) {
+ $this->removeContentHeadersAndContent($from);
+ }
+ }
+
+ /**
+ * Creates a new content part from the passed part, allowing the part to be
+ * used for something else (e.g. changing a non-mime message to a multipart
+ * mime message).
+ *
+ * @param ParentHeaderPart $part
+ * @return MimePart the newly-created MimePart
+ */
+ public function createNewContentPartFrom(ParentHeaderPart $part)
+ {
+ $mime = $this->partBuilderFactory->newPartBuilder($this->mimePartFactory)->createMessagePart();
+ $this->copyContentHeadersAndContent($part, $mime, true);
+ return $mime;
+ }
+
+ /**
+ * Copies type headers (Content-Type, Content-Disposition,
+ * Content-Transfer-Encoding) from the $from MimePart to $to. Attaches the
+ * content resource handle of $from to $to, and loops over child parts,
+ * removing them from $from and adding them to $to.
+ *
+ * @param ParentHeaderPart $from
+ * @param ParentHeaderPart $to
+ */
+ public function movePartContentAndChildren(ParentHeaderPart $from, ParentHeaderPart $to)
+ {
+ $this->copyContentHeadersAndContent($from, $to, true);
+ foreach ($from->getChildParts() as $child) {
+ $from->removePart($child);
+ $to->addChild($child);
+ }
+ }
+
+ /**
+ * Replaces the $part ParentHeaderPart with $replacement.
+ *
+ * Essentially removes $part from its parent, and adds $replacement in its
+ * same position. If $part is this Message, then $part can't be removed and
+ * replaced, and instead $replacement's type headers are copied to $message,
+ * and any children below $replacement are added directly below $message.
+ *
+ * @param Message $message
+ * @param ParentHeaderPart $part
+ * @param ParentHeaderPart $replacement
+ */
+ public function replacePart(Message $message, ParentHeaderPart $part, ParentHeaderPart $replacement)
+ {
+ $position = $message->removePart($replacement);
+ if ($part === $message) {
+ $this->movePartContentAndChildren($replacement, $part);
+ return;
+ }
+ $parent = $part->getParent();
+ $parent->addChild($replacement, $position);
+ }
+}
diff --git a/hdz/vendor/zbateson/mail-mime-parser/src/Message/Helper/MessageHelperService.php b/hdz/vendor/zbateson/mail-mime-parser/src/Message/Helper/MessageHelperService.php
new file mode 100644
index 0000000..98bccc3
--- /dev/null
+++ b/hdz/vendor/zbateson/mail-mime-parser/src/Message/Helper/MessageHelperService.php
@@ -0,0 +1,118 @@
+partBuilderFactory = $partBuilderFactory;
+ }
+
+ /**
+ * Set separately to avoid circular dependencies (PartFactoryService needs a
+ * MessageHelperService).
+ *
+ * @param PartFactoryService $partFactoryService
+ */
+ public function setPartFactoryService(PartFactoryService $partFactoryService)
+ {
+ $this->partFactoryService = $partFactoryService;
+ }
+
+ /**
+ * Returns the GenericHelper singleton
+ *
+ * @return GenericHelper
+ */
+ public function getGenericHelper()
+ {
+ if ($this->genericHelper === null) {
+ $this->genericHelper = new GenericHelper(
+ $this->partFactoryService->getMimePartFactory(),
+ $this->partFactoryService->getUUEncodedPartFactory(),
+ $this->partBuilderFactory
+ );
+ }
+ return $this->genericHelper;
+ }
+
+ /**
+ * Returns the MultipartHelper singleton
+ *
+ * @return MultipartHelper
+ */
+ public function getMultipartHelper()
+ {
+ if ($this->multipartHelper === null) {
+ $this->multipartHelper = new MultipartHelper(
+ $this->partFactoryService->getMimePartFactory(),
+ $this->partFactoryService->getUUEncodedPartFactory(),
+ $this->partBuilderFactory,
+ $this->getGenericHelper()
+ );
+ }
+ return $this->multipartHelper;
+ }
+
+ /**
+ * Returns the PrivacyHelper singleton
+ *
+ * @return PrivacyHelper
+ */
+ public function getPrivacyHelper()
+ {
+ if ($this->privacyHelper === null) {
+ $this->privacyHelper = new PrivacyHelper(
+ $this->partFactoryService->getMimePartFactory(),
+ $this->partFactoryService->getUUEncodedPartFactory(),
+ $this->partBuilderFactory,
+ $this->getGenericHelper(),
+ $this->getMultipartHelper()
+ );
+ }
+ return $this->privacyHelper;
+ }
+}
diff --git a/hdz/vendor/zbateson/mail-mime-parser/src/Message/Helper/MultipartHelper.php b/hdz/vendor/zbateson/mail-mime-parser/src/Message/Helper/MultipartHelper.php
new file mode 100644
index 0000000..618c634
--- /dev/null
+++ b/hdz/vendor/zbateson/mail-mime-parser/src/Message/Helper/MultipartHelper.php
@@ -0,0 +1,441 @@
+genericHelper = $genericHelper;
+ }
+
+ /**
+ * Creates and returns a unique boundary.
+ *
+ * @param string $mimeType first 3 characters of a multipart type are used,
+ * e.g. REL for relative or ALT for alternative
+ * @return string
+ */
+ public function getUniqueBoundary($mimeType)
+ {
+ $type = ltrim(strtoupper(preg_replace('/^(multipart\/(.{3}).*|.*)$/i', '$2-', $mimeType)), '-');
+ return uniqid('----=MMP-' . $type . '.', true);
+ }
+
+ /**
+ * Creates a unique mime boundary and assigns it to the passed part's
+ * Content-Type header with the passed mime type.
+ *
+ * @param ParentHeaderPart $part
+ * @param string $mimeType
+ */
+ public function setMimeHeaderBoundaryOnPart(ParentHeaderPart $part, $mimeType)
+ {
+ $part->setRawHeader(
+ 'Content-Type',
+ "$mimeType;\r\n\tboundary=\""
+ . $this->getUniqueBoundary($mimeType) . '"'
+ );
+ }
+
+ /**
+ * Sets the passed message as multipart/mixed.
+ *
+ * If the message has content, a new part is created and added as a child of
+ * the message. The message's content and content headers are moved to the
+ * new part.
+ *
+ * @param Message $message
+ */
+ public function setMessageAsMixed(Message $message)
+ {
+ if ($message->hasContent()) {
+ $part = $this->genericHelper->createNewContentPartFrom($message);
+ $message->addChild($part, 0);
+ }
+ $this->setMimeHeaderBoundaryOnPart($message, 'multipart/mixed');
+ $atts = $message->getAllAttachmentParts();
+ if (!empty($atts)) {
+ foreach ($atts as $att) {
+ $att->markAsChanged();
+ }
+ }
+ }
+
+ /**
+ * Sets the passed message as multipart/alternative.
+ *
+ * If the message has content, a new part is created and added as a child of
+ * the message. The message's content and content headers are moved to the
+ * new part.
+ *
+ * @param Message $message
+ */
+ public function setMessageAsAlternative(Message $message)
+ {
+ if ($message->hasContent()) {
+ $part = $this->genericHelper->createNewContentPartFrom($message);
+ $message->addChild($part, 0);
+ }
+ $this->setMimeHeaderBoundaryOnPart($message, 'multipart/alternative');
+ }
+
+ /**
+ * Searches the passed $alternativePart for a part with the passed mime type
+ * and returns its parent.
+ *
+ * Used for alternative mime types that have a multipart/mixed or
+ * multipart/related child containing a content part of $mimeType, where
+ * the whole mixed/related part should be removed.
+ *
+ * @param string $mimeType the content-type to find below $alternativePart
+ * @param ParentHeaderPart $alternativePart The multipart/alternative part to look
+ * under
+ * @return boolean|MimePart false if a part is not found
+ */
+ public function getContentPartContainerFromAlternative($mimeType, ParentHeaderPart $alternativePart)
+ {
+ $part = $alternativePart->getPart(0, PartFilter::fromInlineContentType($mimeType));
+ $contPart = null;
+ do {
+ if ($part === null) {
+ return false;
+ }
+ $contPart = $part;
+ $part = $part->getParent();
+ } while ($part !== $alternativePart);
+ return $contPart;
+ }
+
+ /**
+ * Removes all parts of $mimeType from $alternativePart.
+ *
+ * If $alternativePart contains a multipart/mixed or multipart/relative part
+ * with other parts of different content-types, the multipart part is
+ * removed, and parts of different content-types can optionally be moved to
+ * the main message part.
+ *
+ * @param Message $message
+ * @param string $mimeType
+ * @param ParentHeaderPart $alternativePart
+ * @param bool $keepOtherContent
+ * @return bool
+ */
+ public function removeAllContentPartsFromAlternative(Message $message, $mimeType, ParentHeaderPart $alternativePart, $keepOtherContent)
+ {
+ $rmPart = $this->getContentPartContainerFromAlternative($mimeType, $alternativePart);
+ if ($rmPart === false) {
+ return false;
+ }
+ if ($keepOtherContent) {
+ $this->moveAllPartsAsAttachmentsExcept($message, $rmPart, $mimeType);
+ $alternativePart = $message->getPart(0, PartFilter::fromInlineContentType('multipart/alternative'));
+ } else {
+ $rmPart->removeAllParts();
+ }
+ $message->removePart($rmPart);
+ if ($alternativePart !== null) {
+ if ($alternativePart->getChildCount() === 1) {
+ $this->genericHelper->replacePart($message, $alternativePart, $alternativePart->getChild(0));
+ } elseif ($alternativePart->getChildCount() === 0) {
+ $message->removePart($alternativePart);
+ }
+ }
+ while ($message->getChildCount() === 1) {
+ $this->genericHelper->replacePart($message, $message, $message->getChild(0));
+ }
+ return true;
+ }
+
+ /**
+ * Creates a new mime part as a multipart/alternative and assigns the passed
+ * $contentPart as a part below it before returning it.
+ *
+ * @param Message $message
+ * @param MessagePart $contentPart
+ * @return MimePart the alternative part
+ */
+ public function createAlternativeContentPart(Message $message, MessagePart $contentPart)
+ {
+ $altPart = $this->partBuilderFactory->newPartBuilder($this->mimePartFactory)->createMessagePart();
+ $this->setMimeHeaderBoundaryOnPart($altPart, 'multipart/alternative');
+ $message->removePart($contentPart);
+ $message->addChild($altPart, 0);
+ $altPart->addChild($contentPart, 0);
+ return $altPart;
+ }
+
+ /**
+ * Moves all parts under $from into this message except those with a
+ * content-type equal to $exceptMimeType. If the message is not a
+ * multipart/mixed message, it is set to multipart/mixed first.
+ *
+ * @param Message $message
+ * @param ParentHeaderPart $from
+ * @param string $exceptMimeType
+ */
+ public function moveAllPartsAsAttachmentsExcept(Message $message, ParentHeaderPart $from, $exceptMimeType)
+ {
+ $parts = $from->getAllParts(new PartFilter([
+ 'multipart' => PartFilter::FILTER_EXCLUDE,
+ 'headers' => [
+ PartFilter::FILTER_EXCLUDE => [
+ 'Content-Type' => $exceptMimeType
+ ]
+ ]
+ ]));
+ if (strcasecmp($message->getContentType(), 'multipart/mixed') !== 0) {
+ $this->setMessageAsMixed($message);
+ }
+ foreach ($parts as $part) {
+ $from->removePart($part);
+ $message->addChild($part);
+ }
+ }
+
+ /**
+ * Enforces the message to be a mime message for a non-mime (e.g. uuencoded
+ * or unspecified) message. If the message has uuencoded attachments, sets
+ * up the message as a multipart/mixed message and creates a separate
+ * content part.
+ *
+ * @param Message $message
+ */
+ public function enforceMime(Message $message)
+ {
+ if (!$message->isMime()) {
+ if ($message->getAttachmentCount()) {
+ $this->setMessageAsMixed($message);
+ } else {
+ $message->setRawHeader('Content-Type', "text/plain;\r\n\tcharset=\"iso-8859-1\"");
+ }
+ $message->setRawHeader('Mime-Version', '1.0');
+ }
+ }
+
+ /**
+ * Creates a multipart/related part out of 'inline' children of $parent and
+ * returns it.
+ *
+ * @param ParentHeaderPart $parent
+ * @return MimePart
+ */
+ public function createMultipartRelatedPartForInlineChildrenOf(ParentHeaderPart $parent)
+ {
+ $relatedPart = $this->partBuilderFactory->newPartBuilder($this->mimePartFactory)->createMessagePart();
+ $this->setMimeHeaderBoundaryOnPart($relatedPart, 'multipart/related');
+ foreach ($parent->getChildParts(PartFilter::fromDisposition('inline', PartFilter::FILTER_EXCLUDE)) as $part) {
+ $parent->removePart($part);
+ $relatedPart->addChild($part);
+ }
+ $parent->addChild($relatedPart, 0);
+ return $relatedPart;
+ }
+
+ /**
+ * Finds an alternative inline part in the message and returns it if one
+ * exists.
+ *
+ * If the passed $mimeType is text/plain, searches for a text/html part.
+ * Otherwise searches for a text/plain part to return.
+ *
+ * @param Message $message
+ * @param string $mimeType
+ * @return \ZBateson\MailMimeParser\Message\Part\MimeType or null if not
+ * found
+ */
+ public function findOtherContentPartFor(Message $message, $mimeType)
+ {
+ $altPart = $message->getPart(
+ 0,
+ PartFilter::fromInlineContentType(($mimeType === 'text/plain') ? 'text/html' : 'text/plain')
+ );
+ if ($altPart !== null && $altPart->getParent() !== null && $altPart->getParent()->isMultiPart()) {
+ $altPartParent = $altPart->getParent();
+ if ($altPartParent->getChildCount(PartFilter::fromDisposition('inline', PartFilter::FILTER_EXCLUDE)) !== 1) {
+ $altPart = $this->createMultipartRelatedPartForInlineChildrenOf($altPartParent);
+ }
+ }
+ return $altPart;
+ }
+
+ /**
+ * Creates a new content part for the passed mimeType and charset, making
+ * space by creating a multipart/alternative if needed
+ *
+ * @param Message $message
+ * @param string $mimeType
+ * @param string $charset
+ * @return \ZBateson\MailMimeParser\Message\Part\MimePart
+ */
+ public function createContentPartForMimeType(Message $message, $mimeType, $charset)
+ {
+ $builder = $this->partBuilderFactory->newPartBuilder($this->mimePartFactory);
+ $builder->addHeader('Content-Type', "$mimeType;\r\n\tcharset=\"$charset\"");
+ $builder->addHeader('Content-Transfer-Encoding', 'quoted-printable');
+ $this->enforceMime($message);
+ $mimePart = $builder->createMessagePart();
+
+ $altPart = $this->findOtherContentPartFor($message, $mimeType);
+
+ if ($altPart === $message) {
+ $this->setMessageAsAlternative($message);
+ $message->addChild($mimePart);
+ } elseif ($altPart !== null) {
+ $mimeAltPart = $this->createAlternativeContentPart($message, $altPart);
+ $mimeAltPart->addChild($mimePart, 1);
+ } else {
+ $message->addChild($mimePart, 0);
+ }
+
+ return $mimePart;
+ }
+
+ /**
+ * Creates and adds a MimePart for the passed content and options as an
+ * attachment.
+ *
+ * @param Message $message
+ * @param string|resource|Psr\Http\Message\StreamInterface\StreamInterface
+ * $resource
+ * @param string $mimeType
+ * @param string $disposition
+ * @param string $filename
+ * @param string $encoding
+ * @return \ZBateson\MailMimeParser\Message\Part\MimePart
+ */
+ public function createAndAddPartForAttachment(Message $message, $resource, $mimeType, $disposition, $filename = null, $encoding = 'base64')
+ {
+ if ($filename === null) {
+ $filename = 'file' . uniqid();
+ }
+
+ $safe = iconv('UTF-8', 'US-ASCII//translit//ignore', $filename);
+ if ($message->isMime()) {
+ $builder = $this->partBuilderFactory->newPartBuilder($this->mimePartFactory);
+ $builder->addHeader('Content-Transfer-Encoding', $encoding);
+ if (strcasecmp($message->getContentType(), 'multipart/mixed') !== 0) {
+ $this->setMessageAsMixed($message);
+ }
+ $builder->addHeader('Content-Type', "$mimeType;\r\n\tname=\"$safe\"");
+ $builder->addHeader('Content-Disposition', "$disposition;\r\n\tfilename=\"$safe\"");
+ } else {
+ $builder = $this->partBuilderFactory->newPartBuilder(
+ $this->uuEncodedPartFactory
+ );
+ $builder->setProperty('filename', $safe);
+ }
+ $part = $builder->createMessagePart();
+ $part->setContent($resource);
+ $message->addChild($part);
+ }
+
+ /**
+ * Removes the content part of the message with the passed mime type. If
+ * there is a remaining content part and it is an alternative part of the
+ * main message, the content part is moved to the message part.
+ *
+ * If the content part is part of an alternative part beneath the message,
+ * the alternative part is replaced by the remaining content part,
+ * optionally keeping other parts if $keepOtherContent is set to true.
+ *
+ * @param Message $message
+ * @param string $mimeType
+ * @param bool $keepOtherContent
+ * @return boolean true on success
+ */
+ public function removeAllContentPartsByMimeType(Message $message, $mimeType, $keepOtherContent = false)
+ {
+ $alt = $message->getPart(0, PartFilter::fromInlineContentType('multipart/alternative'));
+ if ($alt !== null) {
+ return $this->removeAllContentPartsFromAlternative($message, $mimeType, $alt, $keepOtherContent);
+ }
+ $message->removeAllParts(PartFilter::fromInlineContentType($mimeType));
+ return true;
+ }
+
+ /**
+ * Removes the 'inline' part with the passed contentType, at the given index
+ * defaulting to the first
+ *
+ * @param Message $message
+ * @param string $mimeType
+ * @param int $index
+ * @return boolean true on success
+ */
+ public function removePartByMimeType(Message $message, $mimeType, $index = 0)
+ {
+ $parts = $message->getAllParts(PartFilter::fromInlineContentType($mimeType));
+ $alt = $message->getPart(0, PartFilter::fromInlineContentType('multipart/alternative'));
+ if ($parts === null || !isset($parts[$index])) {
+ return false;
+ } elseif (count($parts) === 1) {
+ return $this->removeAllContentPartsByMimeType($message, $mimeType, true);
+ }
+ $part = $parts[$index];
+ $message->removePart($part);
+ if ($alt !== null && $alt->getChildCount() === 1) {
+ $this->genericHelper->replacePart($message, $alt, $alt->getChild(0));
+ }
+ return true;
+ }
+
+ /**
+ * Either creates a mime part or sets the existing mime part with the passed
+ * mimeType to $strongOrHandle.
+ *
+ * @param Message $message
+ * @param string $mimeType
+ * @param string|resource $stringOrHandle
+ * @param string $charset
+ */
+ public function setContentPartForMimeType(Message $message, $mimeType, $stringOrHandle, $charset)
+ {
+ $part = ($mimeType === 'text/html') ? $message->getHtmlPart() : $message->getTextPart();
+ if ($part === null) {
+ $part = $this->createContentPartForMimeType($message, $mimeType, $charset);
+ } else {
+ $contentType = $part->getContentType();
+ $part->setRawHeader('Content-Type', "$contentType;\r\n\tcharset=\"$charset\"");
+ }
+ $part->setContent($stringOrHandle);
+ }
+}
diff --git a/hdz/vendor/zbateson/mail-mime-parser/src/Message/Helper/PrivacyHelper.php b/hdz/vendor/zbateson/mail-mime-parser/src/Message/Helper/PrivacyHelper.php
new file mode 100644
index 0000000..4a7498f
--- /dev/null
+++ b/hdz/vendor/zbateson/mail-mime-parser/src/Message/Helper/PrivacyHelper.php
@@ -0,0 +1,217 @@
+genericHelper = $genericHelper;
+ $this->multipartHelper = $multipartHelper;
+ }
+
+ /**
+ * The passed message is set as multipart/signed, and a new part is created
+ * below it with content headers, content and children copied from the
+ * message.
+ *
+ * @param Message $message
+ * @param string $micalg
+ * @param string $protocol
+ */
+ public function setMessageAsMultipartSigned(Message $message, $micalg, $protocol)
+ {
+ if (strcasecmp($message->getContentType(), 'multipart/signed') !== 0) {
+ $this->multipartHelper->enforceMime($message);
+ $messagePart = $this->partBuilderFactory->newPartBuilder($this->mimePartFactory)->createMessagePart();
+ $this->genericHelper->movePartContentAndChildren($message, $messagePart);
+ $message->addChild($messagePart);
+ $boundary = $this->multipartHelper->getUniqueBoundary('multipart/signed');
+ $message->setRawHeader(
+ 'Content-Type',
+ "multipart/signed;\r\n\tboundary=\"$boundary\";\r\n\tmicalg=\"$micalg\"; protocol=\"$protocol\""
+ );
+ }
+ $this->overwrite8bitContentEncoding($message);
+ $this->ensureHtmlPartFirstForSignedMessage($message);
+ $this->setSignature($message, 'Empty');
+ }
+
+ /**
+ * Sets the signature of the message to $body, creating a signature part if
+ * one doesn't exist.
+ *
+ * @param Message $message
+ * @param string $body
+ */
+ public function setSignature(Message $message, $body)
+ {
+ $signedPart = $message->getSignaturePart();
+ if ($signedPart === null) {
+ $signedPart = $this->partBuilderFactory->newPartBuilder($this->mimePartFactory)->createMessagePart();
+ $message->addChild($signedPart);
+ }
+ $signedPart->setRawHeader(
+ 'Content-Type',
+ $message->getHeaderParameter('Content-Type', 'protocol')
+ );
+ $signedPart->setContent($body);
+ }
+
+ /**
+ * Loops over parts of the message and sets the content-transfer-encoding
+ * header to quoted-printable for text/* mime parts, and to base64
+ * otherwise for parts that are '8bit' encoded.
+ *
+ * Used for multipart/signed messages which doesn't support 8bit transfer
+ * encodings.
+ *
+ * @param Message $message
+ */
+ public function overwrite8bitContentEncoding(Message $message)
+ {
+ $parts = $message->getAllParts(new PartFilter([
+ 'headers' => [ PartFilter::FILTER_INCLUDE => [
+ 'Content-Transfer-Encoding' => '8bit'
+ ] ]
+ ]));
+ foreach ($parts as $part) {
+ $contentType = strtolower($part->getContentType());
+ if ($contentType === 'text/plain' || $contentType === 'text/html') {
+ $part->setRawHeader('Content-Transfer-Encoding', 'quoted-printable');
+ } else {
+ $part->setRawHeader('Content-Transfer-Encoding', 'base64');
+ }
+ }
+ }
+
+ /**
+ * Ensures a non-text part comes first in a signed multipart/alternative
+ * message as some clients seem to prefer the first content part if the
+ * client doesn't understand multipart/signed.
+ *
+ * @param Message $message
+ */
+ public function ensureHtmlPartFirstForSignedMessage(Message $message)
+ {
+ $alt = $message->getPartByMimeType('multipart/alternative');
+ if ($alt !== null && $alt instanceof ParentPart) {
+ $cont = $this->multipartHelper->getContentPartContainerFromAlternative('text/html', $alt);
+ $children = $alt->getChildParts();
+ $pos = array_search($cont, $children, true);
+ if ($pos !== false && $pos !== 0) {
+ $alt->removePart($children[0]);
+ $alt->addChild($children[0]);
+ }
+ }
+ }
+
+ /**
+ * Returns a stream that can be used to read the content part of a signed
+ * message, which can be used to sign an email or verify a signature.
+ *
+ * The method simply returns the stream for the first child. No
+ * verification of whether the message is in fact a signed message is
+ * performed.
+ *
+ * Note that unlike getSignedMessageAsString, getSignedMessageStream doesn't
+ * replace new lines.
+ *
+ * @param Message $message
+ * @return \Psr\Http\Message\StreamInterface or null if the message doesn't
+ * have any children
+ */
+ public function getSignedMessageStream(Message $message)
+ {
+ $child = $message->getChild(0);
+ if ($child !== null) {
+ return $child->getStream();
+ }
+ return null;
+ }
+
+ /**
+ * Returns a string containing the entire body (content) of a signed message
+ * for verification or calculating a signature.
+ *
+ * Non-CRLF new lines are replaced to always be CRLF.
+ *
+ * @param Message $message
+ * @return string or null if the message doesn't have any children
+ */
+ public function getSignedMessageAsString(Message $message)
+ {
+ $stream = $this->getSignedMessageStream($message);
+ if ($stream !== null) {
+ return preg_replace(
+ '/\r\n|\r|\n/',
+ "\r\n",
+ $stream->getContents()
+ );
+ }
+ return null;
+ }
+
+ /**
+ * Returns the signature part of a multipart/signed message or null.
+ *
+ * The signature part is determined to always be the 2nd child of a
+ * multipart/signed message, the first being the 'body'.
+ *
+ * Using the 'protocol' parameter of the Content-Type header is unreliable
+ * in some instances (for instance a difference of x-pgp-signature versus
+ * pgp-signature).
+ *
+ * @param Message $message
+ * @return \ZBateson\MailMimeParser\Message\Part\MimePart
+ */
+ public function getSignaturePart(Message $message)
+ {
+ if (strcasecmp($message->getContentType(), 'multipart/signed') === 0) {
+ return $message->getChild(1);
+ } else {
+ return null;
+ }
+ }
+}
diff --git a/hdz/vendor/zbateson/mail-mime-parser/src/Message/MessageFactory.php b/hdz/vendor/zbateson/mail-mime-parser/src/Message/MessageFactory.php
new file mode 100644
index 0000000..62419cf
--- /dev/null
+++ b/hdz/vendor/zbateson/mail-mime-parser/src/Message/MessageFactory.php
@@ -0,0 +1,71 @@
+messageHelperService = $mhs;
+ }
+
+ /**
+ * Constructs a new Message object and returns it
+ *
+ * @param PartBuilder $partBuilder
+ * @param StreamInterface $stream
+ * @return \ZBateson\MailMimeParser\Message\Part\MimePart
+ */
+ public function newInstance(PartBuilder $partBuilder, StreamInterface $stream = null)
+ {
+ $contentStream = null;
+ if ($stream !== null) {
+ $contentStream = $this->streamFactory->getLimitedContentStream($stream, $partBuilder);
+ }
+ return new Message(
+ $this->partStreamFilterManagerFactory->newInstance(),
+ $this->streamFactory,
+ $this->partFilterFactory,
+ $partBuilder,
+ $this->messageHelperService,
+ $stream,
+ $contentStream
+ );
+ }
+}
diff --git a/hdz/vendor/zbateson/mail-mime-parser/src/Message/MessageParser.php b/hdz/vendor/zbateson/mail-mime-parser/src/Message/MessageParser.php
new file mode 100644
index 0000000..058c2e6
--- /dev/null
+++ b/hdz/vendor/zbateson/mail-mime-parser/src/Message/MessageParser.php
@@ -0,0 +1,283 @@
+partFactoryService = $pfs;
+ $this->partBuilderFactory = $pbf;
+ }
+
+ /**
+ * Parses the passed stream into a ZBateson\MailMimeParser\Message object
+ * and returns it.
+ *
+ * @param StreamInterface $stream the stream to parse the message from
+ * @return \ZBateson\MailMimeParser\Message
+ */
+ public function parse(StreamInterface $stream)
+ {
+ $partBuilder = $this->read($stream);
+ return $partBuilder->createMessagePart($stream);
+ }
+
+ /**
+ * Ensures the header isn't empty and contains a colon separator character,
+ * then splits it and calls $partBuilder->addHeader.
+ *
+ * @param string $header
+ * @param PartBuilder $partBuilder
+ */
+ private function addRawHeaderToPart($header, PartBuilder $partBuilder)
+ {
+ if ($header !== '' && strpos($header, ':') !== false) {
+ $a = explode(':', $header, 2);
+ $partBuilder->addHeader($a[0], trim($a[1]));
+ }
+ }
+
+ /**
+ * Reads a line of up to 4096 characters. If the line is larger than that,
+ * the remaining characters in the line are read and discarded, and only the
+ * first 4096 characters are returned.
+ *
+ * @param resource $handle
+ * @return string
+ */
+ private function readLine($handle)
+ {
+ $size = 4096;
+ $ret = $line = fgets($handle, $size);
+ while (strlen($line) === $size - 1 && substr($line, -1) !== "\n") {
+ $line = fgets($handle, $size);
+ }
+ return $ret;
+ }
+
+ /**
+ * Reads a line of 2048 characters. If the line is larger than that, the
+ * remaining characters in the line are read and
+ * discarded, and only the first part is returned.
+ *
+ * This method is identical to readLine, except it calculates the number of
+ * characters that make up the line's new line characters (e.g. 2 for "\r\n"
+ * or 1 for "\n").
+ *
+ * @param resource $handle
+ * @param int $lineSeparatorLength
+ * @return string
+ */
+ private function readBoundaryLine($handle, &$lineSeparatorLength = 0)
+ {
+ $size = 2048;
+ $isCut = false;
+ $line = fgets($handle, $size);
+ while (strlen($line) === $size - 1 && substr($line, -1) !== "\n") {
+ $line = fgets($handle, $size);
+ $isCut = true;
+ }
+ $ret = rtrim($line, "\r\n");
+ $lineSeparatorLength = strlen($line) - strlen($ret);
+ return ($isCut) ? '' : $ret;
+ }
+
+ /**
+ * Reads header lines up to an empty line, adding them to the passed
+ * $partBuilder.
+ *
+ * @param resource $handle the resource handle to read from
+ * @param PartBuilder $partBuilder the current part to add headers to
+ */
+ protected function readHeaders($handle, PartBuilder $partBuilder)
+ {
+ $header = '';
+ do {
+ $line = $this->readLine($handle);
+ if (empty($line) || $line[0] !== "\t" && $line[0] !== ' ') {
+ $this->addRawHeaderToPart($header, $partBuilder);
+ $header = '';
+ } else {
+ $line = "\r\n" . $line;
+ }
+ $header .= rtrim($line, "\r\n");
+ } while ($header !== '');
+ }
+
+ /**
+ * Reads lines from the passed $handle, calling
+ * $partBuilder->setEndBoundaryFound with the passed line until it returns
+ * true or the stream is at EOF.
+ *
+ * setEndBoundaryFound returns true if the passed line matches a boundary
+ * for the $partBuilder itself or any of its parents.
+ *
+ * Once a boundary is found, setStreamPartAndContentEndPos is called with
+ * the passed $handle's read pos before the boundary and its line separator
+ * were read.
+ *
+ * @param resource $handle
+ * @param PartBuilder $partBuilder
+ */
+ private function findContentBoundary($handle, PartBuilder $partBuilder)
+ {
+ // last separator before a boundary belongs to the boundary, and is not
+ // part of the current part
+ while (!feof($handle)) {
+ $endPos = ftell($handle) - $this->lastLineSeparatorLength;
+ $line = $this->readBoundaryLine($handle, $this->lastLineSeparatorLength);
+ if ($line !== '' && $partBuilder->setEndBoundaryFound($line)) {
+ $partBuilder->setStreamPartAndContentEndPos($endPos);
+ return;
+ }
+ }
+ $partBuilder->setStreamPartAndContentEndPos(ftell($handle));
+ $partBuilder->setEof();
+ }
+
+ /**
+ * Reads content for a non-mime message. If there are uuencoded attachment
+ * parts in the message (denoted by 'begin' lines), those parts are read and
+ * added to the passed $partBuilder as children.
+ *
+ * @param resource $handle
+ * @param PartBuilder $partBuilder
+ * @return string
+ */
+ protected function readUUEncodedOrPlainTextMessage($handle, PartBuilder $partBuilder)
+ {
+ $partBuilder->setStreamContentStartPos(ftell($handle));
+ $part = $partBuilder;
+ while (!feof($handle)) {
+ $start = ftell($handle);
+ $line = trim($this->readLine($handle));
+ if (preg_match('/^begin ([0-7]{3}) (.*)$/', $line, $matches)) {
+ $part = $this->partBuilderFactory->newPartBuilder(
+ $this->partFactoryService->getUUEncodedPartFactory()
+ );
+ $part->setStreamPartStartPos($start);
+ // 'begin' line is part of the content
+ $part->setStreamContentStartPos($start);
+ $part->setProperty('mode', $matches[1]);
+ $part->setProperty('filename', $matches[2]);
+ $partBuilder->addChild($part);
+ }
+ $part->setStreamPartAndContentEndPos(ftell($handle));
+ }
+ $partBuilder->setStreamPartEndPos(ftell($handle));
+ }
+
+ /**
+ * Reads content for a single part of a MIME message.
+ *
+ * If the part being read is in turn a multipart part, readPart is called on
+ * it recursively to read its headers and content.
+ *
+ * The start/end positions of the part's content are set on the passed
+ * $partBuilder, which in turn sets the end position of the part and its
+ * parents.
+ *
+ * @param resource $handle
+ * @param PartBuilder $partBuilder
+ */
+ private function readPartContent($handle, PartBuilder $partBuilder)
+ {
+ $partBuilder->setStreamContentStartPos(ftell($handle));
+ $this->findContentBoundary($handle, $partBuilder);
+ if ($partBuilder->isMultiPart()) {
+ while (!$partBuilder->isParentBoundaryFound()) {
+ $child = $this->partBuilderFactory->newPartBuilder(
+ $this->partFactoryService->getMimePartFactory()
+ );
+ $partBuilder->addChild($child);
+ $this->readPart($handle, $child);
+ }
+ }
+ }
+
+ /**
+ * Reads a part and any of its children, into the passed $partBuilder,
+ * either by calling readUUEncodedOrPlainTextMessage or readPartContent
+ * after reading headers.
+ *
+ * @param resource $handle
+ * @param PartBuilder $partBuilder
+ */
+ protected function readPart($handle, PartBuilder $partBuilder)
+ {
+ $partBuilder->setStreamPartStartPos(ftell($handle));
+
+ if ($partBuilder->canHaveHeaders()) {
+ $this->readHeaders($handle, $partBuilder);
+ $this->lastLineSeparatorLength = 0;
+ }
+ if ($partBuilder->getParent() === null && !$partBuilder->isMime()) {
+ $this->readUUEncodedOrPlainTextMessage($handle, $partBuilder);
+ } else {
+ $this->readPartContent($handle, $partBuilder);
+ }
+ }
+
+ /**
+ * Reads the message from the passed stream and returns a PartBuilder
+ * representing it.
+ *
+ * @param StreamInterface $stream
+ * @return PartBuilder
+ */
+ protected function read(StreamInterface $stream)
+ {
+ $partBuilder = $this->partBuilderFactory->newPartBuilder(
+ $this->partFactoryService->getMessageFactory()
+ );
+ // the remaining parts use a resource handle for better performance...
+ // it seems fgets does much better than Psr7\readline (not specifically
+ // measured, but difference in running tests is big)
+ $this->readPart(StreamWrapper::getResource($stream), $partBuilder);
+ return $partBuilder;
+ }
+}
diff --git a/hdz/vendor/zbateson/mail-mime-parser/src/Message/Part/Factory/MessagePartFactory.php b/hdz/vendor/zbateson/mail-mime-parser/src/Message/Part/Factory/MessagePartFactory.php
new file mode 100644
index 0000000..58aeccd
--- /dev/null
+++ b/hdz/vendor/zbateson/mail-mime-parser/src/Message/Part/Factory/MessagePartFactory.php
@@ -0,0 +1,120 @@
+streamFactory = $streamFactory;
+ $this->partStreamFilterManagerFactory = $psf;
+ }
+
+ /**
+ * Sets a cached singleton instance.
+ *
+ * @param MessagePartFactory $instance
+ */
+ protected static function setCachedInstance(MessagePartFactory $instance)
+ {
+ if (self::$instances === null) {
+ self::$instances = [];
+ }
+ $class = get_called_class();
+ self::$instances[$class] = $instance;
+ }
+
+ /**
+ * Returns a cached singleton instance if one exists, or null if one hasn't
+ * been created yet.
+ *
+ * @return MessagePartFactory
+ */
+ protected static function getCachedInstance()
+ {
+ $class = get_called_class();
+ if (self::$instances === null || !isset(self::$instances[$class])) {
+ return null;
+ }
+ return self::$instances[$class];
+ }
+
+ /**
+ * Returns the singleton instance for the class.
+ *
+ * @param StreamFactory $sdf
+ * @param PartStreamFilterManagerFactory $psf
+ * @param PartFilterFactory $pf
+ * @param MessageHelperService $mhs
+ * @return MessagePartFactory
+ */
+ public static function getInstance(
+ StreamFactory $sdf,
+ PartStreamFilterManagerFactory $psf,
+ PartFilterFactory $pf = null,
+ MessageHelperService $mhs = null
+ ) {
+ $instance = static::getCachedInstance();
+ if ($instance === null) {
+ $ref = new ReflectionClass(get_called_class());
+ $n = $ref->getConstructor()->getNumberOfParameters();
+ $args = [];
+ for ($i = 0; $i < $n; ++$i) {
+ $args[] = func_get_arg($i);
+ }
+ $instance = $ref->newInstanceArgs($args);
+ static::setCachedInstance($instance);
+ }
+ return $instance;
+ }
+
+ /**
+ * Constructs a new MessagePart object and returns it
+ *
+ * @param PartBuilder $partBuilder
+ * @param StreamInterface $messageStream
+ * @return \ZBateson\MailMimeParser\Message\Part\MessagePart
+ */
+ public abstract function newInstance(PartBuilder $partBuilder, StreamInterface $messageStream = null);
+}
diff --git a/hdz/vendor/zbateson/mail-mime-parser/src/Message/Part/Factory/MimePartFactory.php b/hdz/vendor/zbateson/mail-mime-parser/src/Message/Part/Factory/MimePartFactory.php
new file mode 100644
index 0000000..7960e62
--- /dev/null
+++ b/hdz/vendor/zbateson/mail-mime-parser/src/Message/Part/Factory/MimePartFactory.php
@@ -0,0 +1,67 @@
+partFilterFactory = $pf;
+ }
+
+ /**
+ * Constructs a new MimePart object and returns it
+ *
+ * @param PartBuilder $partBuilder
+ * @param StreamInterface $messageStream
+ * @return \ZBateson\MailMimeParser\Message\Part\MimePart
+ */
+ public function newInstance(PartBuilder $partBuilder, StreamInterface $messageStream = null)
+ {
+ $partStream = null;
+ $contentStream = null;
+ if ($messageStream !== null) {
+ $partStream = $this->streamFactory->getLimitedPartStream($messageStream, $partBuilder);
+ $contentStream = $this->streamFactory->getLimitedContentStream($messageStream, $partBuilder);
+ }
+ return new MimePart(
+ $this->partStreamFilterManagerFactory->newInstance(),
+ $this->streamFactory,
+ $this->partFilterFactory,
+ $partBuilder,
+ $partStream,
+ $contentStream
+ );
+ }
+}
diff --git a/hdz/vendor/zbateson/mail-mime-parser/src/Message/Part/Factory/NonMimePartFactory.php b/hdz/vendor/zbateson/mail-mime-parser/src/Message/Part/Factory/NonMimePartFactory.php
new file mode 100644
index 0000000..097119c
--- /dev/null
+++ b/hdz/vendor/zbateson/mail-mime-parser/src/Message/Part/Factory/NonMimePartFactory.php
@@ -0,0 +1,42 @@
+streamFactory->getLimitedPartStream($messageStream, $partBuilder);
+ $contentStream = $this->streamFactory->getLimitedContentStream($messageStream, $partBuilder);
+ }
+ return new NonMimePart(
+ $this->partStreamFilterManagerFactory->newInstance(),
+ $this->streamFactory,
+ $partStream,
+ $contentStream
+ );
+ }
+}
diff --git a/hdz/vendor/zbateson/mail-mime-parser/src/Message/Part/Factory/PartBuilderFactory.php b/hdz/vendor/zbateson/mail-mime-parser/src/Message/Part/Factory/PartBuilderFactory.php
new file mode 100644
index 0000000..09593dd
--- /dev/null
+++ b/hdz/vendor/zbateson/mail-mime-parser/src/Message/Part/Factory/PartBuilderFactory.php
@@ -0,0 +1,53 @@
+headerFactory = $headerFactory;
+ }
+
+ /**
+ * Constructs a new PartBuilder object and returns it
+ *
+ * @param \ZBateson\MailMimeParser\Message\Part\Factory\MessagePartFactory
+ * $messagePartFactory
+ * @return \ZBateson\MailMimeParser\Message\Part\PartBuilder
+ */
+ public function newPartBuilder(MessagePartFactory $messagePartFactory)
+ {
+ return new PartBuilder(
+ $messagePartFactory,
+ $this->headerFactory->newHeaderContainer()
+ );
+ }
+}
diff --git a/hdz/vendor/zbateson/mail-mime-parser/src/Message/Part/Factory/PartFactoryService.php b/hdz/vendor/zbateson/mail-mime-parser/src/Message/Part/Factory/PartFactoryService.php
new file mode 100644
index 0000000..477ebdb
--- /dev/null
+++ b/hdz/vendor/zbateson/mail-mime-parser/src/Message/Part/Factory/PartFactoryService.php
@@ -0,0 +1,115 @@
+partFilterFactory = $partFilterFactory;
+ $this->streamFactory = $streamFactory;
+ $this->partStreamFilterManagerFactory = $partStreamFilterManagerFactory;
+ $this->messageHelperService = $messageHelperService;
+ }
+
+ /**
+ * Returns the MessageFactory singleton instance.
+ *
+ * @return MessageFactory
+ */
+ public function getMessageFactory()
+ {
+ return MessageFactory::getInstance(
+ $this->streamFactory,
+ $this->partStreamFilterManagerFactory,
+ $this->partFilterFactory,
+ $this->messageHelperService
+ );
+ }
+
+ /**
+ * Returns the MimePartFactory singleton instance.
+ *
+ * @return MimePartFactory
+ */
+ public function getMimePartFactory()
+ {
+ return MimePartFactory::getInstance(
+ $this->streamFactory,
+ $this->partStreamFilterManagerFactory,
+ $this->partFilterFactory
+ );
+ }
+
+ /**
+ * Returns the NonMimePartFactory singleton instance.
+ *
+ * @return NonMimePartFactory
+ */
+ public function getNonMimePartFactory()
+ {
+ return NonMimePartFactory::getInstance(
+ $this->streamFactory,
+ $this->partStreamFilterManagerFactory
+ );
+ }
+
+ /**
+ * Returns the UUEncodedPartFactory singleton instance.
+ *
+ * @return UUEncodedPartFactory
+ */
+ public function getUUEncodedPartFactory()
+ {
+ return UUEncodedPartFactory::getInstance(
+ $this->streamFactory,
+ $this->partStreamFilterManagerFactory
+ );
+ }
+}
diff --git a/hdz/vendor/zbateson/mail-mime-parser/src/Message/Part/Factory/PartStreamFilterManagerFactory.php b/hdz/vendor/zbateson/mail-mime-parser/src/Message/Part/Factory/PartStreamFilterManagerFactory.php
new file mode 100644
index 0000000..6d3ec37
--- /dev/null
+++ b/hdz/vendor/zbateson/mail-mime-parser/src/Message/Part/Factory/PartStreamFilterManagerFactory.php
@@ -0,0 +1,43 @@
+streamFactory = $streamFactory;
+ }
+
+ /**
+ * Constructs a new PartStreamFilterManager object and returns it.
+ *
+ * @return \ZBateson\MailMimeParser\Message\Part\PartStreamFilterManager
+ */
+ public function newInstance()
+ {
+ return new PartStreamFilterManager($this->streamFactory);
+ }
+}
diff --git a/hdz/vendor/zbateson/mail-mime-parser/src/Message/Part/Factory/UUEncodedPartFactory.php b/hdz/vendor/zbateson/mail-mime-parser/src/Message/Part/Factory/UUEncodedPartFactory.php
new file mode 100644
index 0000000..43b3e07
--- /dev/null
+++ b/hdz/vendor/zbateson/mail-mime-parser/src/Message/Part/Factory/UUEncodedPartFactory.php
@@ -0,0 +1,43 @@
+streamFactory->getLimitedPartStream($messageStream, $partBuilder);
+ $contentStream = $this->streamFactory->getLimitedContentStream($messageStream, $partBuilder);
+ }
+ return new UUEncodedPart(
+ $this->partStreamFilterManagerFactory->newInstance(),
+ $this->streamFactory,
+ $partBuilder,
+ $partStream,
+ $contentStream
+ );
+ }
+}
diff --git a/hdz/vendor/zbateson/mail-mime-parser/src/Message/Part/MessagePart.php b/hdz/vendor/zbateson/mail-mime-parser/src/Message/Part/MessagePart.php
new file mode 100644
index 0000000..64359aa
--- /dev/null
+++ b/hdz/vendor/zbateson/mail-mime-parser/src/Message/Part/MessagePart.php
@@ -0,0 +1,532 @@
+partStreamFilterManager = $partStreamFilterManager;
+ $this->streamFactory = $streamFactory;
+
+ $this->stream = $stream;
+ $this->contentStream = $contentStream;
+ if ($contentStream !== null) {
+ $partStreamFilterManager->setStream(
+ $contentStream
+ );
+ }
+ }
+
+ /**
+ * Overridden to close streams.
+ */
+ public function __destruct()
+ {
+ if ($this->stream !== null) {
+ $this->stream->close();
+ }
+ if ($this->contentStream !== null) {
+ $this->contentStream->close();
+ }
+ }
+
+ /**
+ * Called when operations change the content of the MessagePart.
+ *
+ * The function causes calls to getStream() to return a dynamic
+ * MessagePartStream instead of the read stream for this MessagePart and all
+ * parent MessageParts.
+ */
+ protected function onChange()
+ {
+ $this->markAsChanged();
+ if ($this->parent !== null) {
+ $this->parent->onChange();
+ }
+ }
+
+ /**
+ * Marks the part as changed, forcing the part to be rewritten when saved.
+ *
+ * Normal operations to a MessagePart automatically mark the part as
+ * changed and markAsChanged() doesn't need to be called in those cases.
+ *
+ * The function can be called to indicate an external change that requires
+ * rewriting this part, for instance changing a message from a non-mime
+ * message to a mime one, would require rewriting non-mime children to
+ * insure suitable headers are written.
+ *
+ * Internally, the function discards the part's stream, forcing a stream to
+ * be created when calling getStream().
+ */
+ public function markAsChanged()
+ {
+ // the stream is not closed because $this->contentStream may still be
+ // attached to it. GuzzleHttp will clean it up when destroyed.
+ $this->stream = null;
+ }
+
+ /**
+ * Returns true if there's a content stream associated with the part.
+ *
+ * @return boolean
+ */
+ public function hasContent()
+ {
+ return ($this->contentStream !== null);
+ }
+
+ /**
+ * Returns true if this part's mime type is text/plain, text/html or has a
+ * text/* and has a defined 'charset' attribute.
+ *
+ * @return bool
+ */
+ public abstract function isTextPart();
+
+ /**
+ * Returns the mime type of the content.
+ *
+ * @return string
+ */
+ public abstract function getContentType();
+
+ /**
+ * Returns the charset of the content, or null if not applicable/defined.
+ *
+ * @return string
+ */
+ public abstract function getCharset();
+
+ /**
+ * Returns the content's disposition.
+ *
+ * @return string
+ */
+ public abstract function getContentDisposition();
+
+ /**
+ * Returns the content-transfer-encoding used for this part.
+ *
+ * @return string
+ */
+ public abstract function getContentTransferEncoding();
+
+ /**
+ * Returns a filename for the part if one is defined, or null otherwise.
+ *
+ * @return string
+ */
+ public function getFilename()
+ {
+ return null;
+ }
+
+ /**
+ * Returns true if the current part is a mime part.
+ *
+ * @return bool
+ */
+ public abstract function isMime();
+
+ /**
+ * Returns the Content ID of the part, or null if not defined.
+ *
+ * @return string|null
+ */
+ public abstract function getContentId();
+
+ /**
+ * Returns a resource handle containing this part, including any headers for
+ * a MimePart, its content, and all its children.
+ *
+ * @return resource the resource handle
+ */
+ public function getResourceHandle()
+ {
+ return StreamWrapper::getResource($this->getStream());
+ }
+
+ /**
+ * Returns a Psr7 StreamInterface containing this part, including any
+ * headers for a MimePart, its content, and all its children.
+ *
+ * @return StreamInterface the resource handle
+ */
+ public function getStream()
+ {
+ if ($this->stream === null) {
+ return $this->streamFactory->newMessagePartStream($this);
+ }
+ $this->stream->rewind();
+ return $this->stream;
+ }
+
+ /**
+ * Overrides the default character set used for reading content from content
+ * streams in cases where a user knows the source charset is not what is
+ * specified.
+ *
+ * If set, the returned value from MessagePart::getCharset is ignored.
+ *
+ * Note that setting an override on a Message and calling getTextStream,
+ * getTextContent, getHtmlStream or getHtmlContent will not be applied to
+ * those sub-parts, unless the text/html part is the Message itself.
+ * Instead, Message:getTextPart() should be called, and setCharsetOverride
+ * called on the returned MessagePart.
+ *
+ * @param string $charsetOverride
+ * @param boolean $onlyIfNoCharset if true, $charsetOverride is used only if
+ * getCharset returns null.
+ */
+ public function setCharsetOverride($charsetOverride, $onlyIfNoCharset = false)
+ {
+ if (!$onlyIfNoCharset || $this->getCharset() === null) {
+ $this->charsetOverride = $charsetOverride;
+ }
+ }
+
+ /**
+ * Returns a resource handle for the content's stream, or null if the part
+ * doesn't have a content stream.
+ *
+ * The method wraps a call to {@see MessagePart::getContentStream()} and
+ * returns a resource handle for the returned Stream.
+ *
+ * Note: this method should *not* be used and has been deprecated. Instead,
+ * use Psr7 streams with getContentStream. Multibyte chars will not be read
+ * correctly with fread.
+ *
+ * @param string $charset
+ * @deprecated since version 1.2.1
+ * @return resource|null
+ */
+ public function getContentResourceHandle($charset = MailMimeParser::DEFAULT_CHARSET)
+ {
+ trigger_error("getContentResourceHandle is deprecated since version 1.2.1", E_USER_DEPRECATED);
+ $stream = $this->getContentStream($charset);
+ if ($stream !== null) {
+ return StreamWrapper::getResource($stream);
+ }
+ return null;
+ }
+
+ /**
+ * Returns the StreamInterface for the part's content or null if the part
+ * doesn't have a content section.
+ *
+ * The library automatically handles decoding and charset conversion (to the
+ * target passed $charset) based on the part's transfer encoding as returned
+ * by {@see MessagePart::getContentTransferEncoding()} and the part's
+ * charset as returned by {@see MessagePart::getCharset()}. The returned
+ * stream is ready to be read from directly.
+ *
+ * Note that the returned Stream is a shared object. If called multiple
+ * time with the same $charset, and the value of the part's
+ * Content-Transfer-Encoding header not having changed, the stream will be
+ * rewound. This would affect other existing variables referencing the
+ * stream, for example:
+ *
+ * ```
+ * // assuming $part is a part containing the following
+ * // string for its content: '12345678'
+ * $stream = $part->getContentStream();
+ * $someChars = $part->read(4);
+ *
+ * $stream2 = $part->getContentStream();
+ * $moreChars = $part->read(4);
+ * echo ($someChars === $moreChars); //1
+ * ```
+ *
+ * In this case the Stream was rewound, and $stream's second call to read 4
+ * bytes reads the same first 4.
+ *
+ * @param string $charset
+ * @return StreamInterface
+ */
+ public function getContentStream($charset = MailMimeParser::DEFAULT_CHARSET)
+ {
+ if ($this->hasContent()) {
+ $tr = ($this->ignoreTransferEncoding) ? '' : $this->getContentTransferEncoding();
+ $ch = ($this->charsetOverride !== null) ? $this->charsetOverride : $this->getCharset();
+ return $this->partStreamFilterManager->getContentStream(
+ $tr,
+ $ch,
+ $charset
+ );
+ }
+ return null;
+ }
+
+ /**
+ * Returns the raw data stream for the current part, if it exists, or null
+ * if there's no content associated with the stream.
+ *
+ * This is basically the same as calling
+ * {@see MessagePart::getContentStream()}, except no automatic charset
+ * conversion is done. Note that for non-text streams, this doesn't have an
+ * effect, as charset conversion is not performed in that case, and is
+ * useful only when:
+ *
+ * - The charset defined is not correct, and the conversion produces errors;
+ * or
+ * - You'd like to read the raw contents without conversion, for instance to
+ * save it to file or allow a user to download it as-is (in a download
+ * link for example).
+ *
+ * @param string $charset
+ * @return StreamInterface
+ */
+ public function getBinaryContentStream()
+ {
+ if ($this->hasContent()) {
+ $tr = ($this->ignoreTransferEncoding) ? '' : $this->getContentTransferEncoding();
+ return $this->partStreamFilterManager->getBinaryStream($tr);
+ }
+ return null;
+ }
+
+ /**
+ * Returns a resource handle for the content's raw data stream, or null if
+ * the part doesn't have a content stream.
+ *
+ * The method wraps a call to {@see MessagePart::getBinaryContentStream()}
+ * and returns a resource handle for the returned Stream.
+ *
+ * @return resource|null
+ */
+ public function getBinaryContentResourceHandle()
+ {
+ $stream = $this->getBinaryContentStream();
+ if ($stream !== null) {
+ return StreamWrapper::getResource($stream);
+ }
+ return null;
+ }
+
+ /**
+ * Saves the binary content of the stream to the passed file, resource or
+ * stream.
+ *
+ * Note that charset conversion is not performed in this case, and the
+ * contents of the part are saved in their binary format as transmitted (but
+ * after any content-transfer decoding is performed). {@see
+ * MessagePart::getBinaryContentStream()} for a more detailed description of
+ * the stream.
+ *
+ * If the passed parameter is a string, it's assumed to be a filename to
+ * write to. The file is opened in 'w+' mode, and closed before returning.
+ *
+ * When passing a resource or Psr7 Stream, the resource is not closed, nor
+ * rewound.
+ *
+ * @param string|resource|Stream $filenameResourceOrStream
+ */
+ public function saveContent($filenameResourceOrStream)
+ {
+ $resourceOrStream = $filenameResourceOrStream;
+ if (is_string($filenameResourceOrStream)) {
+ $resourceOrStream = fopen($filenameResourceOrStream, 'w+');
+ }
+
+ $stream = Psr7\stream_for($resourceOrStream);
+ Psr7\copy_to_stream($this->getBinaryContentStream(), $stream);
+
+ if (!is_string($filenameResourceOrStream)
+ && !($filenameResourceOrStream instanceof StreamInterface)) {
+ // only detach if it wasn't a string or StreamInterface, so the
+ // fopen call can be properly closed if it was
+ $stream->detach();
+ }
+ }
+
+ /**
+ * Shortcut to reading stream content and assigning it to a string. Returns
+ * null if the part doesn't have a content stream.
+ *
+ * The returned string is encoded to the passed $charset character encoding,
+ * defaulting to UTF-8.
+ *
+ * @see MessagePart::getContentStream()
+ * @param string $charset
+ * @return string
+ */
+ public function getContent($charset = MailMimeParser::DEFAULT_CHARSET)
+ {
+ $stream = $this->getContentStream($charset);
+ if ($stream !== null) {
+ return $stream->getContents();
+ }
+ return null;
+ }
+
+ /**
+ * Returns this part's parent.
+ *
+ * @return \ZBateson\MailMimeParser\Message\Part\MimePart
+ */
+ public function getParent()
+ {
+ return $this->parent;
+ }
+
+ /**
+ * Attaches the stream or resource handle for the part's content. The
+ * stream is closed when another stream is attached, or the MimePart is
+ * destroyed.
+ *
+ * @param StreamInterface $stream
+ * @param string $streamCharset
+ */
+ public function attachContentStream(StreamInterface $stream, $streamCharset = MailMimeParser::DEFAULT_CHARSET)
+ {
+ if ($this->contentStream !== null && $this->contentStream !== $stream) {
+ $this->contentStream->close();
+ }
+ $this->contentStream = $stream;
+ $ch = ($this->charsetOverride !== null) ? $this->charsetOverride : $this->getCharset();
+ if ($ch !== null && $streamCharset !== $ch) {
+ $this->charsetOverride = $streamCharset;
+ }
+ $this->ignoreTransferEncoding = true;
+ $this->partStreamFilterManager->setStream($stream);
+ $this->onChange();
+ }
+
+ /**
+ * Detaches and closes the content stream.
+ */
+ public function detachContentStream()
+ {
+ $this->contentStream = null;
+ $this->partStreamFilterManager->setStream(null);
+ $this->onChange();
+ }
+
+ /**
+ * Sets the content of the part to the passed resource.
+ *
+ * @param string|resource|StreamInterface $resource
+ * @param string $charset
+ */
+ public function setContent($resource, $charset = MailMimeParser::DEFAULT_CHARSET)
+ {
+ $stream = Psr7\stream_for($resource);
+ $this->attachContentStream($stream, $charset);
+ // this->onChange called in attachContentStream
+ }
+
+ /**
+ * Saves the message/part to the passed file, resource, or stream.
+ *
+ * If the passed parameter is a string, it's assumed to be a filename to
+ * write to. The file is opened in 'w+' mode, and closed before returning.
+ *
+ * When passing a resource or Psr7 Stream, the resource is not closed, nor
+ * rewound.
+ *
+ * @param string|resource|StreamInterface $filenameResourceOrStream
+ */
+ public function save($filenameResourceOrStream)
+ {
+ $resourceOrStream = $filenameResourceOrStream;
+ if (is_string($filenameResourceOrStream)) {
+ $resourceOrStream = fopen($filenameResourceOrStream, 'w+');
+ }
+
+ $partStream = $this->getStream();
+ $partStream->rewind();
+ $stream = Psr7\stream_for($resourceOrStream);
+ Psr7\copy_to_stream($partStream, $stream);
+
+ if (!is_string($filenameResourceOrStream)
+ && !($filenameResourceOrStream instanceof StreamInterface)) {
+ // only detach if it wasn't a string or StreamInterface, so the
+ // fopen call can be properly closed if it was
+ $stream->detach();
+ }
+ }
+
+ /**
+ * Returns the message/part as a string.
+ *
+ * Convenience method for calling getStream()->getContents().
+ *
+ * @return string
+ */
+ public function __toString()
+ {
+ return $this->getStream()->getContents();
+ }
+}
diff --git a/hdz/vendor/zbateson/mail-mime-parser/src/Message/Part/MimePart.php b/hdz/vendor/zbateson/mail-mime-parser/src/Message/Part/MimePart.php
new file mode 100644
index 0000000..ecc0c87
--- /dev/null
+++ b/hdz/vendor/zbateson/mail-mime-parser/src/Message/Part/MimePart.php
@@ -0,0 +1,178 @@
+getContentType()
+ ));
+ }
+
+ /**
+ * Returns a filename for the part if one is defined, or null otherwise.
+ *
+ * @return string
+ */
+ public function getFilename()
+ {
+ return $this->getHeaderParameter(
+ 'Content-Disposition',
+ 'filename',
+ $this->getHeaderParameter(
+ 'Content-Type',
+ 'name'
+ )
+ );
+ }
+
+ /**
+ * Returns true.
+ *
+ * @return bool
+ */
+ public function isMime()
+ {
+ return true;
+ }
+
+ /**
+ * Returns true if this part's mime type is text/plain, text/html or if the
+ * Content-Type header defines a charset.
+ *
+ * @return bool
+ */
+ public function isTextPart()
+ {
+ return ($this->getCharset() !== null);
+ }
+
+ /**
+ * Returns the lower-cased, trimmed value of the Content-Type header.
+ *
+ * Parses the Content-Type header, defaults to returning text/plain if not
+ * defined.
+ *
+ * @param string $default pass to override the returned value when not set
+ * @return string
+ */
+ public function getContentType($default = 'text/plain')
+ {
+ return trim(strtolower($this->getHeaderValue('Content-Type', $default)));
+ }
+
+ /**
+ * Returns the upper-cased charset of the Content-Type header's charset
+ * parameter if set, ISO-8859-1 if the Content-Type is text/plain or
+ * text/html and the charset parameter isn't set, or null otherwise.
+ *
+ * If the charset parameter is set to 'binary' it is ignored and considered
+ * 'not set' (returns ISO-8859-1 for text/plain, text/html or null
+ * otherwise).
+ *
+ * @return string
+ */
+ public function getCharset()
+ {
+ $charset = $this->getHeaderParameter('Content-Type', 'charset');
+ if ($charset === null || strcasecmp($charset, 'binary') === 0) {
+ $contentType = $this->getContentType();
+ if ($contentType === 'text/plain' || $contentType === 'text/html') {
+ return 'ISO-8859-1';
+ }
+ return null;
+ }
+ return trim(strtoupper($charset));
+ }
+
+ /**
+ * Returns the content's disposition, defaulting to 'inline' if not set.
+ *
+ * @param string $default pass to override the default returned disposition
+ * when not set.
+ * @return string
+ */
+ public function getContentDisposition($default = 'inline')
+ {
+ return strtolower($this->getHeaderValue('Content-Disposition', $default));
+ }
+
+ /**
+ * Returns the content-transfer-encoding used for this part, defaulting to
+ * '7bit' if not set.
+ *
+ * @param string $default pass to override the default when not set.
+ * @return string
+ */
+ public function getContentTransferEncoding($default = '7bit')
+ {
+ static $translated = [
+ 'x-uue' => 'x-uuencode',
+ 'uue' => 'x-uuencode',
+ 'uuencode' => 'x-uuencode'
+ ];
+ $type = strtolower($this->getHeaderValue('Content-Transfer-Encoding', $default));
+ if (isset($translated[$type])) {
+ return $translated[$type];
+ }
+ return $type;
+ }
+
+ /**
+ * Returns the Content ID of the part.
+ *
+ * In MimePart, this is merely a shortcut to calling
+ * ``` $part->getHeaderValue('Content-ID'); ```.
+ *
+ * @return string|null
+ */
+ public function getContentId()
+ {
+ return $this->getHeaderValue('Content-ID');
+ }
+
+ /**
+ * Convenience method to find a part by its Content-ID header.
+ *
+ * @param string $contentId
+ * @return MessagePart
+ */
+ public function getPartByContentId($contentId)
+ {
+ $sanitized = preg_replace('/^\s*<|>\s*$/', '', $contentId);
+ $filter = $this->partFilterFactory->newFilterFromArray([
+ 'headers' => [
+ PartFilter::FILTER_INCLUDE => [
+ 'Content-ID' => $sanitized
+ ]
+ ]
+ ]);
+ return $this->getPart(0, $filter);
+ }
+}
diff --git a/hdz/vendor/zbateson/mail-mime-parser/src/Message/Part/NonMimePart.php b/hdz/vendor/zbateson/mail-mime-parser/src/Message/Part/NonMimePart.php
new file mode 100644
index 0000000..4c2ea2e
--- /dev/null
+++ b/hdz/vendor/zbateson/mail-mime-parser/src/Message/Part/NonMimePart.php
@@ -0,0 +1,92 @@
+headerContainer = $partBuilder->getHeaderContainer();
+ }
+
+ /**
+ * Returns the AbstractHeader object for the header with the given $name.
+ * If the optional $offset is passed, and multiple headers exist with the
+ * same name, the one at the passed offset is returned.
+ *
+ * Note that mime headers aren't case sensitive.
+ *
+ * @param string $name
+ * @param int $offset
+ * @return \ZBateson\MailMimeParser\Header\AbstractHeader|
+ * \ZBateson\MailMimeParser\Header\AddressHeader|
+ * \ZBateson\MailMimeParser\Header\DateHeader|
+ * \ZBateson\MailMimeParser\Header\GenericHeader|
+ * \ZBateson\MailMimeParser\Header\IdHeader|
+ * \ZBateson\MailMimeParser\Header\ParameterHeader|
+ * \ZBateson\MailMimeParser\Header\ReceivedHeader|
+ * \ZBateson\MailMimeParser\Header\SubjectHeader
+ */
+ public function getHeader($name, $offset = 0)
+ {
+ return $this->headerContainer->get($name, $offset);
+ }
+
+ /**
+ * Returns an array of headers in this part.
+ *
+ * @return \ZBateson\MailMimeParser\Header\AbstractHeader[]
+ */
+ public function getAllHeaders()
+ {
+ return $this->headerContainer->getHeaderObjects();
+ }
+
+ /**
+ * Returns an array of headers that match the passed name.
+ *
+ * @param string $name
+ * @return \ZBateson\MailMimeParser\Header\AbstractHeader[]
+ */
+ public function getAllHeadersByName($name)
+ {
+ return $this->headerContainer->getAll($name);
+ }
+
+ /**
+ * Returns an array of all headers for the mime part with the first element
+ * holding the name, and the second its value.
+ *
+ * @return string[][]
+ */
+ public function getRawHeaders()
+ {
+ return $this->headerContainer->getHeaders();
+ }
+
+ /**
+ * Returns an iterator to the headers in this collection. Each returned
+ * element is an array with its first element set to the header's name, and
+ * the second to its raw value:
+ *
+ * [ 'Header-Name', 'Header Value' ]
+ *
+ * @return \Iterator
+ */
+ public function getRawHeaderIterator()
+ {
+ return $this->headerContainer->getIterator();
+ }
+
+ /**
+ * Returns the string value for the header with the given $name.
+ *
+ * Note that mime headers aren't case sensitive.
+ *
+ * @param string $name
+ * @param string $defaultValue
+ * @return string
+ */
+ public function getHeaderValue($name, $defaultValue = null)
+ {
+ $header = $this->getHeader($name);
+ if ($header !== null) {
+ return $header->getValue();
+ }
+ return $defaultValue;
+ }
+
+ /**
+ * Returns a parameter of the header $header, given the parameter named
+ * $param.
+ *
+ * Only headers of type
+ * \ZBateson\MailMimeParser\Header\ParameterHeader have parameters.
+ * Content-Type and Content-Disposition are examples of headers with
+ * parameters. "Charset" is a common parameter of Content-Type.
+ *
+ * @param string $header
+ * @param string $param
+ * @param string $defaultValue
+ * @return string
+ */
+ public function getHeaderParameter($header, $param, $defaultValue = null)
+ {
+ $obj = $this->getHeader($header);
+ if ($obj && $obj instanceof ParameterHeader) {
+ return $obj->getValueFor($param, $defaultValue);
+ }
+ return $defaultValue;
+ }
+
+ /**
+ * Adds a header with the given $name and $value. An optional $offset may
+ * be passed, which will overwrite a header if one exists with the given
+ * name and offset. Otherwise a new header is added. The passed $offset may
+ * be ignored in that case if it doesn't represent the next insert position
+ * for the header with the passed name... instead it would be 'pushed' on at
+ * the next position.
+ *
+ * ```php
+ * $part = $myParentHeaderPart;
+ * $part->setRawHeader('New-Header', 'value');
+ * echo $part->getHeaderValue('New-Header'); // 'value'
+ *
+ * $part->setRawHeader('New-Header', 'second', 4);
+ * echo is_null($part->getHeader('New-Header', 4)); // '1' (true)
+ * echo $part->getHeader('New-Header', 1)
+ * ->getValue(); // 'second'
+ * ```
+ *
+ * A new \ZBateson\MailMimeParser\Header\AbstractHeader object is created
+ * from the passed value. No processing on the passed string is performed,
+ * and so the passed name and value must be formatted correctly according to
+ * related RFCs. In particular, be careful to encode non-ascii data, to
+ * keep lines under 998 characters in length, and to follow any special
+ * formatting required for the type of header.
+ *
+ * @param string $name
+ * @param string $value
+ * @param int $offset
+ */
+ public function setRawHeader($name, $value, $offset = 0)
+ {
+ $this->headerContainer->set($name, $value, $offset);
+ $this->onChange();
+ }
+
+ /**
+ * Adds a header with the given $name and $value.
+ *
+ * Note: If a header with the passed name already exists, a new header is
+ * created with the same name. This should only be used when that is
+ * intentional - in most cases setRawHeader should be called.
+ *
+ * Creates a new \ZBateson\MailMimeParser\Header\AbstractHeader object and
+ * registers it as a header.
+ *
+ * @param string $name
+ * @param string $value
+ */
+ public function addRawHeader($name, $value)
+ {
+ $this->headerContainer->add($name, $value);
+ $this->onChange();
+ }
+
+ /**
+ * Removes all headers from this part with the passed name.
+ *
+ * @param string $name
+ */
+ public function removeHeader($name)
+ {
+ $this->headerContainer->removeAll($name);
+ $this->onChange();
+ }
+
+ /**
+ * Removes a single header with the passed name (in cases where more than
+ * one may exist, and others should be preserved).
+ *
+ * @param string $name
+ */
+ public function removeSingleHeader($name, $offset = 0)
+ {
+ $this->headerContainer->remove($name, $offset);
+ $this->onChange();
+ }
+}
diff --git a/hdz/vendor/zbateson/mail-mime-parser/src/Message/Part/ParentPart.php b/hdz/vendor/zbateson/mail-mime-parser/src/Message/Part/ParentPart.php
new file mode 100644
index 0000000..a357566
--- /dev/null
+++ b/hdz/vendor/zbateson/mail-mime-parser/src/Message/Part/ParentPart.php
@@ -0,0 +1,293 @@
+partFilterFactory = $partFilterFactory;
+
+ $pbChildren = $partBuilder->getChildren();
+ if (!empty($pbChildren)) {
+ $this->children = array_map(function ($child) use ($stream) {
+ $childPart = $child->createMessagePart($stream);
+ $childPart->parent = $this;
+ return $childPart;
+ }, $pbChildren);
+ }
+ }
+
+ /**
+ * Returns all parts, including the current object, and all children below
+ * it (including children of children, etc...)
+ *
+ * @return MessagePart[]
+ */
+ protected function getAllNonFilteredParts()
+ {
+ $parts = [ $this ];
+ foreach ($this->children as $part) {
+ if ($part instanceof MimePart) {
+ $parts = array_merge(
+ $parts,
+ $part->getAllNonFilteredParts()
+ );
+ } else {
+ array_push($parts, $part);
+ }
+ }
+ return $parts;
+ }
+
+ /**
+ * Returns the part at the given 0-based index, or null if none is set.
+ *
+ * Note that the first part returned is the current part itself. This is
+ * often desirable for queries with a PartFilter, e.g. looking for a
+ * MessagePart with a specific Content-Type that may be satisfied by the
+ * current part.
+ *
+ * @param int $index
+ * @param PartFilter $filter
+ * @return MessagePart
+ */
+ public function getPart($index, PartFilter $filter = null)
+ {
+ $parts = $this->getAllParts($filter);
+ if (!isset($parts[$index])) {
+ return null;
+ }
+ return $parts[$index];
+ }
+
+ /**
+ * Returns the current part, all child parts, and child parts of all
+ * children optionally filtering them with the provided PartFilter.
+ *
+ * The first part returned is always the current MimePart. This is often
+ * desirable as it may be a valid MimePart for the provided PartFilter.
+ *
+ * @param PartFilter $filter an optional filter
+ * @return MessagePart[]
+ */
+ public function getAllParts(PartFilter $filter = null)
+ {
+ $parts = $this->getAllNonFilteredParts();
+ if (!empty($filter)) {
+ return array_values(array_filter(
+ $parts,
+ [ $filter, 'filter' ]
+ ));
+ }
+ return $parts;
+ }
+
+ /**
+ * Returns the total number of parts in this and all children.
+ *
+ * Note that the current part is considered, so the minimum getPartCount is
+ * 1 without a filter.
+ *
+ * @param PartFilter $filter
+ * @return int
+ */
+ public function getPartCount(PartFilter $filter = null)
+ {
+ return count($this->getAllParts($filter));
+ }
+
+ /**
+ * Returns the direct child at the given 0-based index, or null if none is
+ * set.
+ *
+ * @param int $index
+ * @param PartFilter $filter
+ * @return MessagePart
+ */
+ public function getChild($index, PartFilter $filter = null)
+ {
+ $parts = $this->getChildParts($filter);
+ if (!isset($parts[$index])) {
+ return null;
+ }
+ return $parts[$index];
+ }
+
+ /**
+ * Returns all direct child parts.
+ *
+ * If a PartFilter is provided, the PartFilter is applied before returning.
+ *
+ * @param PartFilter $filter
+ * @return MessagePart[]
+ */
+ public function getChildParts(PartFilter $filter = null)
+ {
+ if ($filter !== null) {
+ return array_values(array_filter($this->children, [ $filter, 'filter' ]));
+ }
+ return $this->children;
+ }
+
+ /**
+ * Returns the number of direct children under this part.
+ *
+ * @param PartFilter $filter
+ * @return int
+ */
+ public function getChildCount(PartFilter $filter = null)
+ {
+ return count($this->getChildParts($filter));
+ }
+
+ /**
+ * Returns the part associated with the passed mime type, at the passed
+ * index, if it exists.
+ *
+ * @param string $mimeType
+ * @param int $index
+ * @return MessagePart|null
+ */
+ public function getPartByMimeType($mimeType, $index = 0)
+ {
+ $partFilter = $this->partFilterFactory->newFilterFromContentType($mimeType);
+ return $this->getPart($index, $partFilter);
+ }
+
+ /**
+ * Returns an array of all parts associated with the passed mime type if any
+ * exist or null otherwise.
+ *
+ * @param string $mimeType
+ * @return MessagePart[] or null
+ */
+ public function getAllPartsByMimeType($mimeType)
+ {
+ $partFilter = $this->partFilterFactory->newFilterFromContentType($mimeType);
+ return $this->getAllParts($partFilter);
+ }
+
+ /**
+ * Returns the number of parts matching the passed $mimeType
+ *
+ * @param string $mimeType
+ * @return int
+ */
+ public function getCountOfPartsByMimeType($mimeType)
+ {
+ $partFilter = $this->partFilterFactory->newFilterFromContentType($mimeType);
+ return $this->getPartCount($partFilter);
+ }
+
+ /**
+ * Registers the passed part as a child of the current part.
+ *
+ * If the $position parameter is non-null, adds the part at the passed
+ * position index.
+ *
+ * @param MessagePart $part
+ * @param int $position
+ */
+ public function addChild(MessagePart $part, $position = null)
+ {
+ if ($part !== $this) {
+ $part->parent = $this;
+ array_splice(
+ $this->children,
+ ($position === null) ? count($this->children) : $position,
+ 0,
+ [ $part ]
+ );
+ $this->onChange();
+ }
+ }
+
+ /**
+ * Removes the child part from this part and returns its position or
+ * null if it wasn't found.
+ *
+ * Note that if the part is not a direct child of this part, the returned
+ * position is its index within its parent (calls removePart on its direct
+ * parent).
+ *
+ * @param MessagePart $part
+ * @return int or null if not found
+ */
+ public function removePart(MessagePart $part)
+ {
+ $parent = $part->getParent();
+ if ($this !== $parent && $parent !== null) {
+ return $parent->removePart($part);
+ } else {
+ $position = array_search($part, $this->children, true);
+ if ($position !== false && is_int($position)) {
+ array_splice($this->children, $position, 1);
+ $this->onChange();
+ return $position;
+ }
+ }
+ return null;
+ }
+
+ /**
+ * Removes all parts that are matched by the passed PartFilter.
+ *
+ * Note: the current part will not be removed. Although the function naming
+ * matches getAllParts, which returns the current part, it also doesn't only
+ * remove direct children like getChildParts. Internally this function uses
+ * getAllParts but the current part is filtered out if returned.
+ *
+ * @param \ZBateson\MailMimeParser\Message\PartFilter $filter
+ */
+ public function removeAllParts(PartFilter $filter = null)
+ {
+ foreach ($this->getAllParts($filter) as $part) {
+ if ($part === $this) {
+ continue;
+ }
+ $this->removePart($part);
+ }
+ }
+}
diff --git a/hdz/vendor/zbateson/mail-mime-parser/src/Message/Part/PartBuilder.php b/hdz/vendor/zbateson/mail-mime-parser/src/Message/Part/PartBuilder.php
new file mode 100644
index 0000000..f8a8226
--- /dev/null
+++ b/hdz/vendor/zbateson/mail-mime-parser/src/Message/Part/PartBuilder.php
@@ -0,0 +1,422 @@
+ value pairs of properties passed on to the
+ * $messagePartFactory when constructing the Message and its children.
+ */
+ private $properties = [];
+
+ /**
+ * Sets up class dependencies.
+ *
+ * @param MessagePartFactory $mpf
+ * @param HeaderContainer $headerContainer
+ */
+ public function __construct(
+ MessagePartFactory $mpf,
+ HeaderContainer $headerContainer
+ ) {
+ $this->messagePartFactory = $mpf;
+ $this->headerContainer = $headerContainer;
+ }
+
+ /**
+ * Adds a header with the given $name and $value to the headers array.
+ *
+ * Removes non-alphanumeric characters from $name, and sets it to lower-case
+ * to use as a key in the private headers array. Sets the original $name
+ * and $value as elements in the headers' array value for the calculated
+ * key.
+ *
+ * @param string $name
+ * @param string $value
+ */
+ public function addHeader($name, $value)
+ {
+ $this->headerContainer->add($name, $value);
+ }
+
+ /**
+ * Returns the HeaderContainer object containing parsed headers.
+ *
+ * @return HeaderContainer
+ */
+ public function getHeaderContainer()
+ {
+ return $this->headerContainer;
+ }
+
+ /**
+ * Sets the specified property denoted by $name to $value.
+ *
+ * @param string $name
+ * @param mixed $value
+ */
+ public function setProperty($name, $value)
+ {
+ $this->properties[$name] = $value;
+ }
+
+ /**
+ * Returns the value of the property with the given $name.
+ *
+ * @param string $name
+ * @return mixed
+ */
+ public function getProperty($name)
+ {
+ if (!isset($this->properties[$name])) {
+ return null;
+ }
+ return $this->properties[$name];
+ }
+
+ /**
+ * Registers the passed PartBuilder as a child of the current PartBuilder.
+ *
+ * @param \ZBateson\MailMimeParser\Message\PartBuilder $partBuilder
+ */
+ public function addChild(PartBuilder $partBuilder)
+ {
+ $partBuilder->parent = $this;
+ // discard parts added after the end boundary
+ if (!$this->endBoundaryFound) {
+ $this->children[] = $partBuilder;
+ }
+ }
+
+ /**
+ * Returns all children PartBuilder objects.
+ *
+ * @return \ZBateson\MailMimeParser\Message\PartBuilder[]
+ */
+ public function getChildren()
+ {
+ return $this->children;
+ }
+
+ /**
+ * Returns this PartBuilder's parent.
+ *
+ * @return PartBuilder
+ */
+ public function getParent()
+ {
+ return $this->parent;
+ }
+
+ /**
+ * Returns true if either a Content-Type or Mime-Version header are defined
+ * in this PartBuilder's headers.
+ *
+ * @return boolean
+ */
+ public function isMime()
+ {
+ return ($this->headerContainer->exists('Content-Type') ||
+ $this->headerContainer->exists('Mime-Version'));
+ }
+
+ /**
+ * Returns a ParameterHeader representing the parsed Content-Type header for
+ * this PartBuilder.
+ *
+ * @return \ZBateson\MailMimeParser\Header\ParameterHeader
+ */
+ public function getContentType()
+ {
+ return $this->headerContainer->get('Content-Type');
+ }
+
+ /**
+ * Returns the parsed boundary parameter of the Content-Type header if set
+ * for a multipart message part.
+ *
+ * @return string
+ */
+ public function getMimeBoundary()
+ {
+ if ($this->mimeBoundary === false) {
+ $this->mimeBoundary = null;
+ $contentType = $this->getContentType();
+ if ($contentType !== null) {
+ $this->mimeBoundary = $contentType->getValueFor('boundary');
+ }
+ }
+ return $this->mimeBoundary;
+ }
+
+ /**
+ * Returns true if this part's content-type is multipart/*
+ *
+ * @return boolean
+ */
+ public function isMultiPart()
+ {
+ $contentType = $this->getContentType();
+ if ($contentType !== null) {
+ // casting to bool, preg_match returns 1 for true
+ return (bool) (preg_match(
+ '~multipart/.*~i',
+ $contentType->getValue()
+ ));
+ }
+ return false;
+ }
+
+ /**
+ * Returns true if the passed $line of read input matches this PartBuilder's
+ * mime boundary, or any of its parent's mime boundaries for a multipart
+ * message.
+ *
+ * If the passed $line is the ending boundary for the current PartBuilder,
+ * $this->isEndBoundaryFound will return true after.
+ *
+ * @param string $line
+ * @return boolean
+ */
+ public function setEndBoundaryFound($line)
+ {
+ $boundary = $this->getMimeBoundary();
+ if ($this->parent !== null && $this->parent->setEndBoundaryFound($line)) {
+ $this->parentBoundaryFound = true;
+ return true;
+ } elseif ($boundary !== null) {
+ if ($line === "--$boundary--") {
+ $this->endBoundaryFound = true;
+ return true;
+ } elseif ($line === "--$boundary") {
+ return true;
+ }
+ }
+ return false;
+ }
+
+ /**
+ * Returns true if MessageParser passed an input line to setEndBoundary that
+ * matches a parent's mime boundary, and the following input belongs to a
+ * new part under its parent.
+ *
+ * @return boolean
+ */
+ public function isParentBoundaryFound()
+ {
+ return ($this->parentBoundaryFound);
+ }
+
+ /**
+ * Called once EOF is reached while reading content. The method sets the
+ * flag used by PartBuilder::isParentBoundaryFound to true on this part and
+ * all parent PartBuilders.
+ */
+ public function setEof()
+ {
+ $this->parentBoundaryFound = true;
+ if ($this->parent !== null) {
+ $this->parent->parentBoundaryFound = true;
+ }
+ }
+
+ /**
+ * Returns false if this part has a parent part in which endBoundaryFound is
+ * set to true (i.e. this isn't a discardable part following the parent's
+ * end boundary line).
+ *
+ * @return boolean
+ */
+ public function canHaveHeaders()
+ {
+ return ($this->parent === null || !$this->parent->endBoundaryFound);
+ }
+
+ /**
+ * Returns the offset for this part's stream within its parent stream.
+ *
+ * @return int
+ */
+ public function getStreamPartStartOffset()
+ {
+ if ($this->parent) {
+ return $this->streamPartStartPos - $this->parent->streamPartStartPos;
+ }
+ return $this->streamPartStartPos;
+ }
+
+ /**
+ * Returns the length of this part's stream.
+ *
+ * @return int
+ */
+ public function getStreamPartLength()
+ {
+ return $this->streamPartEndPos - $this->streamPartStartPos;
+ }
+
+ /**
+ * Returns the offset for this part's content within its part stream.
+ *
+ * @return int
+ */
+ public function getStreamContentStartOffset()
+ {
+ if ($this->parent) {
+ return $this->streamContentStartPos - $this->parent->streamPartStartPos;
+ }
+ return $this->streamContentStartPos;
+ }
+
+ /**
+ * Returns the length of this part's content stream.
+ *
+ * @return int
+ */
+ public function getStreamContentLength()
+ {
+ return $this->streamContentEndPos - $this->streamContentStartPos;
+ }
+
+ /**
+ * Sets the start position of the part in the input stream.
+ *
+ * @param int $streamPartStartPos
+ */
+ public function setStreamPartStartPos($streamPartStartPos)
+ {
+ $this->streamPartStartPos = $streamPartStartPos;
+ }
+
+ /**
+ * Sets the end position of the part in the input stream, and also calls
+ * parent->setParentStreamPartEndPos to expand to parent parts.
+ *
+ * @param int $streamPartEndPos
+ */
+ public function setStreamPartEndPos($streamPartEndPos)
+ {
+ $this->streamPartEndPos = $streamPartEndPos;
+ if ($this->parent !== null) {
+ $this->parent->setStreamPartEndPos($streamPartEndPos);
+ }
+ }
+
+ /**
+ * Sets the start position of the content in the input stream.
+ *
+ * @param int $streamContentStartPos
+ */
+ public function setStreamContentStartPos($streamContentStartPos)
+ {
+ $this->streamContentStartPos = $streamContentStartPos;
+ }
+
+ /**
+ * Sets the end position of the content and part in the input stream.
+ *
+ * @param int $streamContentEndPos
+ */
+ public function setStreamPartAndContentEndPos($streamContentEndPos)
+ {
+ $this->streamContentEndPos = $streamContentEndPos;
+ $this->setStreamPartEndPos($streamContentEndPos);
+ }
+
+ /**
+ * Creates a MessagePart and returns it using the PartBuilder's
+ * MessagePartFactory passed in during construction.
+ *
+ * @param StreamInterface $stream
+ * @return MessagePart
+ */
+ public function createMessagePart(StreamInterface $stream = null)
+ {
+ return $this->messagePartFactory->newInstance(
+ $this,
+ $stream
+ );
+ }
+}
diff --git a/hdz/vendor/zbateson/mail-mime-parser/src/Message/Part/PartStreamFilterManager.php b/hdz/vendor/zbateson/mail-mime-parser/src/Message/Part/PartStreamFilterManager.php
new file mode 100644
index 0000000..5d5e40f
--- /dev/null
+++ b/hdz/vendor/zbateson/mail-mime-parser/src/Message/Part/PartStreamFilterManager.php
@@ -0,0 +1,251 @@
+ null,
+ 'filter' => null
+ ];
+
+ /**
+ * @var array map of the active charset filter on the current handle.
+ */
+ private $charset = [
+ 'from' => null,
+ 'to' => null,
+ 'filter' => null
+ ];
+
+ /**
+ * @var StreamFactory used to apply psr7 stream decorators to the
+ * attached StreamInterface based on encoding.
+ */
+ private $streamFactory;
+
+ /**
+ * Sets up filter names used for stream_filter_append
+ *
+ * @param StreamFactory $streamFactory
+ */
+ public function __construct(StreamFactory $streamFactory)
+ {
+ $this->streamFactory = $streamFactory;
+ }
+
+ /**
+ * Sets the URL used to open the content resource handle.
+ *
+ * The function also closes the currently attached handle if any.
+ *
+ * @param StreamInterface $stream
+ */
+ public function setStream(StreamInterface $stream = null)
+ {
+ $this->stream = $stream;
+ $this->decodedStream = null;
+ $this->charsetStream = null;
+ }
+
+ /**
+ * Returns true if the attached stream filter used for decoding the content
+ * on the current handle is different from the one passed as an argument.
+ *
+ * @param string $transferEncoding
+ * @return boolean
+ */
+ private function isTransferEncodingFilterChanged($transferEncoding)
+ {
+ return ($transferEncoding !== $this->encoding['type']);
+ }
+
+ /**
+ * Returns true if the attached stream filter used for charset conversion on
+ * the current handle is different from the one needed based on the passed
+ * arguments.
+ *
+ * @param string $fromCharset
+ * @param string $toCharset
+ * @return boolean
+ */
+ private function isCharsetFilterChanged($fromCharset, $toCharset)
+ {
+ return ($fromCharset !== $this->charset['from']
+ || $toCharset !== $this->charset['to']);
+ }
+
+ /**
+ * Attaches a decoding filter to the attached content handle, for the passed
+ * $transferEncoding.
+ *
+ * @param string $transferEncoding
+ */
+ protected function attachTransferEncodingFilter($transferEncoding)
+ {
+ if ($this->decodedStream !== null) {
+ $this->encoding['type'] = $transferEncoding;
+ $assign = null;
+ switch ($transferEncoding) {
+ case 'base64':
+ $assign = $this->streamFactory->newBase64Stream($this->decodedStream);
+ break;
+ case 'x-uuencode':
+ $assign = $this->streamFactory->newUUStream($this->decodedStream);
+ break;
+ case 'quoted-printable':
+ $assign = $this->streamFactory->newQuotedPrintableStream($this->decodedStream);
+ break;
+ }
+ if ($assign !== null) {
+ $this->decodedStream = new CachingStream($assign);
+ }
+ }
+ }
+
+ /**
+ * Attaches a charset conversion filter to the attached content handle, for
+ * the passed arguments.
+ *
+ * @param string $fromCharset the character set the content is encoded in
+ * @param string $toCharset the target encoding to return
+ */
+ protected function attachCharsetFilter($fromCharset, $toCharset)
+ {
+ if ($this->charsetStream !== null) {
+ $this->charsetStream = new CachingStream($this->streamFactory->newCharsetStream(
+ $this->charsetStream,
+ $fromCharset,
+ $toCharset
+ ));
+ $this->charset['from'] = $fromCharset;
+ $this->charset['to'] = $toCharset;
+ }
+ }
+
+ /**
+ * Resets just the charset stream, and rewinds the decodedStream.
+ */
+ private function resetCharsetStream()
+ {
+ $this->charset = [
+ 'from' => null,
+ 'to' => null,
+ 'filter' => null
+ ];
+ $this->decodedStream->rewind();
+ $this->charsetStream = $this->decodedStream;
+ }
+
+ /**
+ * Resets cached encoding and charset streams, and rewinds the stream.
+ */
+ public function reset()
+ {
+ $this->encoding = [
+ 'type' => null,
+ 'filter' => null
+ ];
+ $this->charset = [
+ 'from' => null,
+ 'to' => null,
+ 'filter' => null
+ ];
+ $this->stream->rewind();
+ $this->decodedStream = $this->stream;
+ $this->charsetStream = $this->stream;
+ }
+
+ /**
+ * Checks what transfer-encoding decoder stream and charset conversion
+ * stream are currently attached on the underlying stream, and resets them
+ * if the requested arguments differ from the currently assigned ones.
+ *
+ * @param string $transferEncoding
+ * @param string $fromCharset the character set the content is encoded in
+ * @param string $toCharset the target encoding to return
+ * @return StreamInterface
+ */
+ public function getContentStream($transferEncoding, $fromCharset, $toCharset)
+ {
+ if ($this->stream === null) {
+ return null;
+ }
+ if (empty($fromCharset) || empty($toCharset)) {
+ return $this->getBinaryStream($transferEncoding);
+ }
+ if ($this->charsetStream === null
+ || $this->isTransferEncodingFilterChanged($transferEncoding)
+ || $this->isCharsetFilterChanged($fromCharset, $toCharset)) {
+ if ($this->charsetStream === null
+ || $this->isTransferEncodingFilterChanged($transferEncoding)) {
+ $this->reset();
+ $this->attachTransferEncodingFilter($transferEncoding);
+ }
+ $this->resetCharsetStream();
+ $this->attachCharsetFilter($fromCharset, $toCharset);
+ }
+ $this->charsetStream->rewind();
+ return $this->charsetStream;
+ }
+
+ /**
+ * Checks what transfer-encoding decoder stream is attached on the
+ * underlying stream, and resets it if the requested arguments differ.
+ *
+ * @param string $transferEncoding
+ * @return StreamInterface
+ */
+ public function getBinaryStream($transferEncoding)
+ {
+ if ($this->stream === null) {
+ return null;
+ }
+ if ($this->decodedStream === null
+ || $this->isTransferEncodingFilterChanged($transferEncoding)) {
+ $this->reset();
+ $this->attachTransferEncodingFilter($transferEncoding);
+ }
+ $this->decodedStream->rewind();
+ return $this->decodedStream;
+ }
+}
diff --git a/hdz/vendor/zbateson/mail-mime-parser/src/Message/Part/UUEncodedPart.php b/hdz/vendor/zbateson/mail-mime-parser/src/Message/Part/UUEncodedPart.php
new file mode 100644
index 0000000..7d1c7fe
--- /dev/null
+++ b/hdz/vendor/zbateson/mail-mime-parser/src/Message/Part/UUEncodedPart.php
@@ -0,0 +1,151 @@
+mode = intval($partBuilder->getProperty('mode'));
+ $this->filename = $partBuilder->getProperty('filename');
+ }
+
+ /**
+ * Returns the file mode included in the uuencoded header for this part.
+ *
+ * @return int
+ */
+ public function getUnixFileMode()
+ {
+ return $this->mode;
+ }
+
+ /**
+ * Returns the filename included in the uuencoded header for this part.
+ *
+ * @return string
+ */
+ public function getFilename()
+ {
+ return $this->filename;
+ }
+
+ /**
+ * Sets the unix file mode for the uuencoded header.
+ *
+ * @param int $mode
+ */
+ public function setUnixFileMode($mode)
+ {
+ $this->mode = $mode;
+ $this->onChange();
+ }
+
+ /**
+ * Sets the filename included in the uuencoded header.
+ *
+ * @param string $filename
+ */
+ public function setFilename($filename)
+ {
+ $this->filename = $filename;
+ $this->onChange();
+ }
+
+ /**
+ * Returns false.
+ *
+ * @return bool
+ */
+ public function isTextPart()
+ {
+ return false;
+ }
+
+ /**
+ * Returns text/plain
+ *
+ * @return string
+ */
+ public function getContentType()
+ {
+ return 'application/octet-stream';
+ }
+
+ /**
+ * Returns null
+ *
+ * @return string
+ */
+ public function getCharset()
+ {
+ return null;
+ }
+
+ /**
+ * Returns 'inline'.
+ *
+ * @return string
+ */
+ public function getContentDisposition()
+ {
+ return 'attachment';
+ }
+
+ /**
+ * Returns 'x-uuencode'.
+ *
+ * @return string
+ */
+ public function getContentTransferEncoding()
+ {
+ return 'x-uuencode';
+ }
+}
diff --git a/hdz/vendor/zbateson/mail-mime-parser/src/Message/PartFilter.php b/hdz/vendor/zbateson/mail-mime-parser/src/Message/PartFilter.php
new file mode 100644
index 0000000..39767c2
--- /dev/null
+++ b/hdz/vendor/zbateson/mail-mime-parser/src/Message/PartFilter.php
@@ -0,0 +1,411 @@
+getAllParts(new PartFilter([
+ * 'multipart' => PartFilter::FILTER_INCLUDE,
+ * 'headers' => [
+ * FILTER_EXCLUDE => [
+ * 'Content-Disposition': 'attachment'
+ * ]
+ * ]
+ * ]));
+ *
+ * $inlineTextPart = $message->getAllParts(PartFilter::fromInlineContentType('text/plain'));
+ * ```
+ *
+ * @author Zaahid Bateson
+ */
+class PartFilter
+{
+ /**
+ * @var int indicates a filter is not in use
+ */
+ const FILTER_OFF = 0;
+
+ /**
+ * @var int an excluded filter must not be included in a part
+ */
+ const FILTER_EXCLUDE = 1;
+
+ /**
+ * @var int an included filter must be included in a part
+ */
+ const FILTER_INCLUDE = 2;
+
+ /**
+ * @var int filters based on whether MessagePart::hasContent is true
+ */
+ private $hascontent = PartFilter::FILTER_OFF;
+
+ /**
+ * @var int filters based on whether MimePart::isMultiPart is true
+ */
+ private $multipart = PartFilter::FILTER_OFF;
+
+ /**
+ * @var int filters based on whether MessagePart::isTextPart is true
+ */
+ private $textpart = PartFilter::FILTER_OFF;
+
+ /**
+ * @var int filters based on whether the parent of a part is a
+ * multipart/signed part and this part has a content-type equal to its
+ * parent's 'protocol' parameter in its content-type header
+ */
+ private $signedpart = PartFilter::FILTER_EXCLUDE;
+
+ /**
+ * @var string calculated hash of the filter
+ */
+ private $hashCode;
+
+ /**
+ * @var string[][] array of header rules. The top-level contains keys of
+ * FILTER_INCLUDE and/or FILTER_EXCLUDE, which contain key => value mapping
+ * of header names => values to search for. Note that when searching
+ * MimePart::getHeaderValue is used (so additional parameters need not be
+ * matched) and strcasecmp is used.
+ *
+ * ```php
+ * $filter = new PartFilter();
+ * $filter->headers = [ PartFilter::FILTER_INCLUDE => [ 'Content-Type' => 'text/plain' ] ];
+ * ```
+ */
+ private $headers = [];
+
+ /**
+ * Convenience method to filter for a specific mime type.
+ *
+ * @param string $mimeType
+ * @return PartFilter
+ */
+ public static function fromContentType($mimeType)
+ {
+ return new static([
+ 'headers' => [
+ static::FILTER_INCLUDE => [
+ 'Content-Type' => $mimeType
+ ]
+ ]
+ ]);
+ }
+
+ /**
+ * Convenience method to look for parts of a specific mime-type, and that
+ * do not specifically have a Content-Disposition equal to 'attachment'.
+ *
+ * @param string $mimeType
+ * @return PartFilter
+ */
+ public static function fromInlineContentType($mimeType)
+ {
+ return new static([
+ 'headers' => [
+ static::FILTER_INCLUDE => [
+ 'Content-Type' => $mimeType
+ ],
+ static::FILTER_EXCLUDE => [
+ 'Content-Disposition' => 'attachment'
+ ]
+ ]
+ ]);
+ }
+
+ /**
+ * Convenience method to search for parts with a specific
+ * Content-Disposition, optionally including multipart parts.
+ *
+ * @param string $disposition
+ * @param int $multipart
+ * @return PartFilter
+ */
+ public static function fromDisposition($disposition, $multipart = PartFilter::FILTER_OFF)
+ {
+ return new static([
+ 'multipart' => $multipart,
+ 'headers' => [
+ static::FILTER_INCLUDE => [
+ 'Content-Disposition' => $disposition
+ ]
+ ]
+ ]);
+ }
+
+ /**
+ * Constructs a PartFilter, optionally instantiating member variables with
+ * values in the passed array.
+ *
+ * The passed array must use keys equal to member variable names, e.g.
+ * 'multipart', 'textpart', 'signedpart' and 'headers'.
+ *
+ * @param array $filter
+ */
+ public function __construct(array $filter = [])
+ {
+ $params = [ 'hascontent', 'multipart', 'textpart', 'signedpart', 'headers' ];
+ foreach ($params as $param) {
+ if (isset($filter[$param])) {
+ $this->__set($param, $filter[$param]);
+ }
+ }
+ }
+
+ /**
+ * Validates an argument passed to __set to insure it's set to a value in
+ * $valid.
+ *
+ * @param string $name Name of the member variable
+ * @param string $value The value to test
+ * @param array $valid an array of valid values
+ * @throws InvalidArgumentException
+ */
+ private function validateArgument($name, $value, array $valid)
+ {
+ if (!in_array($value, $valid)) {
+ $last = array_pop($valid);
+ throw new InvalidArgumentException(
+ '$value parameter for ' . $name . ' must be one of '
+ . join(', ', $valid) . ' or ' . $last . ' - "' . $value
+ . '" provided'
+ );
+ }
+ }
+
+ /**
+ * Sets the PartFilter's headers filter to the passed array after validating
+ * it.
+ *
+ * @param array $headers
+ * @throws InvalidArgumentException
+ */
+ public function setHeaders(array $headers)
+ {
+ array_walk($headers, function ($v, $k) {
+ $this->validateArgument(
+ 'headers',
+ $k,
+ [ static::FILTER_EXCLUDE, static::FILTER_INCLUDE ]
+ );
+ if (!is_array($v)) {
+ throw new InvalidArgumentException(
+ '$value must be an array with keys set to FILTER_EXCLUDE, '
+ . 'FILTER_INCLUDE and values set to an array of header '
+ . 'name => values'
+ );
+ }
+ });
+ $this->headers = $headers;
+ }
+
+ /**
+ * Sets the member variable denoted by $name to the passed $value after
+ * validating it.
+ *
+ * @param string $name
+ * @param int|array $value
+ * @throws InvalidArgumentException
+ */
+ public function __set($name, $value)
+ {
+ if ($name === 'hascontent' || $name === 'multipart'
+ || $name === 'textpart' || $name === 'signedpart') {
+ if (is_array($value)) {
+ throw new InvalidArgumentException('$value must be not be an array');
+ }
+ $this->validateArgument(
+ $name,
+ $value,
+ [ static::FILTER_OFF, static::FILTER_EXCLUDE, static::FILTER_INCLUDE ]
+ );
+ $this->$name = $value;
+ } elseif ($name === 'headers') {
+ if (!is_array($value)) {
+ throw new InvalidArgumentException('$value must be an array');
+ }
+ $this->setHeaders($value);
+ }
+ }
+
+ /**
+ * Returns true if the variable denoted by $name is a member variable of
+ * PartFilter.
+ *
+ * @param string $name
+ * @return bool
+ */
+ public function __isset($name)
+ {
+ return isset($this->$name);
+ }
+
+ /**
+ * Returns the value of the member variable denoted by $name
+ *
+ * @param string $name
+ * @return mixed
+ */
+ public function __get($name)
+ {
+ return $this->$name;
+ }
+
+ /**
+ * Returns true if the passed MessagePart fails the filter's hascontent
+ * filter settings.
+ *
+ * @param MessagePart $part
+ * @return bool
+ */
+ private function failsHasContentFilter(MessagePart $part)
+ {
+ return ($this->hascontent === static::FILTER_EXCLUDE && $part->hasContent())
+ || ($this->hascontent === static::FILTER_INCLUDE && !$part->hasContent());
+ }
+
+ /**
+ * Returns true if the passed MessagePart fails the filter's multipart
+ * filter settings.
+ *
+ * @param MessagePart $part
+ * @return bool
+ */
+ private function failsMultiPartFilter(MessagePart $part)
+ {
+ if (!($part instanceof MimePart)) {
+ return $this->multipart !== static::FILTER_EXCLUDE;
+ }
+ return ($this->multipart === static::FILTER_EXCLUDE && $part->isMultiPart())
+ || ($this->multipart === static::FILTER_INCLUDE && !$part->isMultiPart());
+ }
+
+ /**
+ * Returns true if the passed MessagePart fails the filter's textpart filter
+ * settings.
+ *
+ * @param MessagePart $part
+ * @return bool
+ */
+ private function failsTextPartFilter(MessagePart $part)
+ {
+ return ($this->textpart === static::FILTER_EXCLUDE && $part->isTextPart())
+ || ($this->textpart === static::FILTER_INCLUDE && !$part->isTextPart());
+ }
+
+ /**
+ * Returns true if the passed MessagePart fails the filter's signedpart
+ * filter settings.
+ *
+ * @param MessagePart $part
+ * @return boolean
+ */
+ private function failsSignedPartFilter(MessagePart $part)
+ {
+ if ($this->signedpart === static::FILTER_OFF) {
+ return false;
+ } elseif (!$part->isMime() || $part->getParent() === null) {
+ return ($this->signedpart === static::FILTER_INCLUDE);
+ }
+ $partMimeType = $part->getContentType();
+ $parentMimeType = $part->getParent()->getContentType();
+ $parentProtocol = $part->getParent()->getHeaderParameter('Content-Type', 'protocol');
+ if (strcasecmp($parentMimeType, 'multipart/signed') === 0 && strcasecmp($partMimeType, $parentProtocol) === 0) {
+ return ($this->signedpart === static::FILTER_EXCLUDE);
+ }
+ return ($this->signedpart === static::FILTER_INCLUDE);
+ }
+
+ /**
+ * Tests a single header value against $part, and returns true if the test
+ * fails.
+ *
+ * @staticvar array $map
+ * @param MessagePart $part
+ * @param int $type
+ * @param string $name
+ * @param string $header
+ * @return boolean
+ */
+ private function failsHeaderFor(MessagePart $part, $type, $name, $header)
+ {
+ $headerValue = null;
+
+ static $map = [
+ 'content-type' => 'getContentType',
+ 'content-disposition' => 'getContentDisposition',
+ 'content-transfer-encoding' => 'getContentTransferEncoding',
+ 'content-id' => 'getContentId'
+ ];
+ $lower = strtolower($name);
+ if (isset($map[$lower])) {
+ $headerValue = call_user_func([$part, $map[$lower]]);
+ } elseif (!($part instanceof MimePart)) {
+ return ($type === static::FILTER_INCLUDE);
+ } else {
+ $headerValue = $part->getHeaderValue($name);
+ }
+
+ return (($type === static::FILTER_EXCLUDE && strcasecmp($headerValue, $header) === 0)
+ || ($type === static::FILTER_INCLUDE && strcasecmp($headerValue, $header) !== 0));
+ }
+
+ /**
+ * Returns true if the passed MessagePart fails the filter's header filter
+ * settings.
+ *
+ * @param MessagePart $part
+ * @return boolean
+ */
+ private function failsHeaderPartFilter(MessagePart $part)
+ {
+ foreach ($this->headers as $type => $values) {
+ foreach ($values as $name => $header) {
+ if ($this->failsHeaderFor($part, $type, $name, $header)) {
+ return true;
+ }
+ }
+ }
+ return false;
+ }
+
+ /**
+ * Determines if the passed MessagePart should be filtered out or not.
+ * If the MessagePart passes all filter tests, true is returned. Otherwise
+ * false is returned.
+ *
+ * @param MessagePart $part
+ * @return boolean
+ */
+ public function filter(MessagePart $part)
+ {
+ return !($this->failsMultiPartFilter($part)
+ || $this->failsTextPartFilter($part)
+ || $this->failsSignedPartFilter($part)
+ || $this->failsHeaderPartFilter($part));
+ }
+}
diff --git a/hdz/vendor/zbateson/mail-mime-parser/src/Message/PartFilterFactory.php b/hdz/vendor/zbateson/mail-mime-parser/src/Message/PartFilterFactory.php
new file mode 100644
index 0000000..ee27cc3
--- /dev/null
+++ b/hdz/vendor/zbateson/mail-mime-parser/src/Message/PartFilterFactory.php
@@ -0,0 +1,80 @@
+part = $part;
+ }
+
+ /**
+ * Returns a header array for the current part.
+ *
+ * If the part is not a MimePart, Content-Type, Content-Disposition and
+ * Content-Transfer-Encoding headers are generated manually.
+ *
+ * @return array
+ */
+ private function getPartHeadersIterator()
+ {
+ if ($this->part instanceof ParentHeaderPart) {
+ return $this->part->getRawHeaderIterator();
+ } elseif ($this->part->getParent() !== null && $this->part->getParent()->isMime()) {
+ return new ArrayIterator([
+ [ 'Content-Type', $this->part->getContentType() ],
+ [ 'Content-Disposition', $this->part->getContentDisposition() ],
+ [ 'Content-Transfer-Encoding', $this->part->getContentTransferEncoding() ]
+ ]);
+ }
+ return new ArrayIterator();
+ }
+
+ /**
+ * Writes out headers for $this->part and follows them with an empty line.
+ *
+ * @param StreamInterface $stream
+ */
+ public function writePartHeadersTo(StreamInterface $stream)
+ {
+ foreach ($this->getPartHeadersIterator() as $header) {
+ $stream->write("${header[0]}: ${header[1]}\r\n");
+ }
+ $stream->write("\r\n");
+ }
+
+ /**
+ * Creates the underlying stream lazily when required.
+ *
+ * @return StreamInterface
+ */
+ protected function createStream()
+ {
+ $stream = Psr7\stream_for();
+ $this->writePartHeadersTo($stream);
+ $stream->rewind();
+ return $stream;
+ }
+}
diff --git a/hdz/vendor/zbateson/mail-mime-parser/src/Stream/MessagePartStream.php b/hdz/vendor/zbateson/mail-mime-parser/src/Stream/MessagePartStream.php
new file mode 100644
index 0000000..e8965e1
--- /dev/null
+++ b/hdz/vendor/zbateson/mail-mime-parser/src/Stream/MessagePartStream.php
@@ -0,0 +1,191 @@
+streamFactory = $sdf;
+ $this->part = $part;
+ }
+
+ /**
+ * Attaches and returns a CharsetStream decorator to the passed $stream.
+ *
+ * If the current attached MessagePart doesn't specify a charset, $stream is
+ * returned as-is.
+ *
+ * @param StreamInterface $stream
+ * @return StreamInterface
+ */
+ private function getCharsetDecoratorForStream(StreamInterface $stream)
+ {
+ $charset = $this->part->getCharset();
+ if (!empty($charset)) {
+ $stream = $this->streamFactory->newCharsetStream(
+ $stream,
+ $charset,
+ MailMimeParser::DEFAULT_CHARSET
+ );
+ }
+ return $stream;
+ }
+
+ /**
+ * Attaches and returns a transfer encoding stream decorator to the passed
+ * $stream.
+ *
+ * The attached stream decorator is based on the attached part's returned
+ * value from MessagePart::getContentTransferEncoding, using one of the
+ * following stream decorators as appropriate:
+ *
+ * o QuotedPrintableStream
+ * o Base64Stream
+ * o UUStream
+ *
+ * @param StreamInterface $stream
+ * @return StreamInterface
+ */
+ private function getTransferEncodingDecoratorForStream(StreamInterface $stream)
+ {
+ $encoding = $this->part->getContentTransferEncoding();
+ $decorator = null;
+ switch ($encoding) {
+ case 'quoted-printable':
+ $decorator = $this->streamFactory->newQuotedPrintableStream($stream);
+ break;
+ case 'base64':
+ $decorator = $this->streamFactory->newBase64Stream(
+ $this->streamFactory->newChunkSplitStream($stream));
+ break;
+ case 'x-uuencode':
+ $decorator = $this->streamFactory->newUUStream($stream);
+ $decorator->setFilename($this->part->getFilename());
+ break;
+ default:
+ return $stream;
+ }
+ return $decorator;
+ }
+
+ /**
+ * Writes out the content portion of the attached mime part to the passed
+ * $stream.
+ *
+ * @param StreamInterface $stream
+ */
+ private function writePartContentTo(StreamInterface $stream)
+ {
+ $contentStream = $this->part->getContentStream();
+ if ($contentStream !== null) {
+ $copyStream = $this->streamFactory->newNonClosingStream($stream);
+ $es = $this->getTransferEncodingDecoratorForStream($copyStream);
+ $cs = $this->getCharsetDecoratorForStream($es);
+ Psr7\copy_to_stream($contentStream, $cs);
+ $cs->close();
+ }
+ }
+
+ /**
+ * Creates an array of streams based on the attached part's mime boundary
+ * and child streams.
+ *
+ * @param ParentHeaderPart $part passed in because $this->part is declared
+ * as MessagePart
+ * @return StreamInterface[]
+ */
+ protected function getBoundaryAndChildStreams(ParentHeaderPart $part)
+ {
+ $boundary = $part->getHeaderParameter('Content-Type', 'boundary');
+ if ($boundary === null) {
+ return array_map(
+ function ($child) {
+ return $child->getStream();
+ },
+ $part->getChildParts()
+ );
+ }
+ $streams = [];
+ foreach ($part->getChildParts() as $i => $child) {
+ if ($i !== 0 || $part->hasContent()) {
+ $streams[] = Psr7\stream_for("\r\n");
+ }
+ $streams[] = Psr7\stream_for("--$boundary\r\n");
+ $streams[] = $child->getStream();
+ }
+ $streams[] = Psr7\stream_for("\r\n--$boundary--\r\n");
+
+ return $streams;
+ }
+
+ /**
+ * Returns an array of Psr7 Streams representing the attached part and it's
+ * direct children.
+ *
+ * @return StreamInterface[]
+ */
+ protected function getStreamsArray()
+ {
+ $content = Psr7\stream_for();
+ $this->writePartContentTo($content);
+ $content->rewind();
+ $streams = [ $this->streamFactory->newHeaderStream($this->part), $content ];
+
+ /**
+ * @var ParentHeaderPart
+ */
+ $part = $this->part;
+ if ($part instanceof ParentHeaderPart && $part->getChildCount()) {
+ $streams = array_merge($streams, $this->getBoundaryAndChildStreams($part));
+ }
+
+ return $streams;
+ }
+
+ /**
+ * Creates the underlying stream lazily when required.
+ *
+ * @return StreamInterface
+ */
+ protected function createStream()
+ {
+ return new AppendStream($this->getStreamsArray());
+ }
+}
diff --git a/hdz/vendor/zbateson/mail-mime-parser/src/Stream/StreamFactory.php b/hdz/vendor/zbateson/mail-mime-parser/src/Stream/StreamFactory.php
new file mode 100644
index 0000000..cd22a18
--- /dev/null
+++ b/hdz/vendor/zbateson/mail-mime-parser/src/Stream/StreamFactory.php
@@ -0,0 +1,176 @@
+getStreamPartLength() and
+ * $part->getStreamPartStartOffset()
+ *
+ * @param StreamInterface $stream
+ * @param PartBuilder $part
+ * @return SeekingLimitStream
+ */
+ public function getLimitedPartStream(StreamInterface $stream, PartBuilder $part)
+ {
+ return $this->newLimitStream(
+ $stream,
+ $part->getStreamPartLength(),
+ $part->getStreamPartStartOffset()
+ );
+ }
+
+ /**
+ * Returns a SeekingLimitStream using $part->getStreamContentLength() and
+ * $part->getStreamContentStartOffset()
+ *
+ * @param StreamInterface $stream
+ * @param PartBuilder $part
+ * @return SeekingLimitStream
+ */
+ public function getLimitedContentStream(StreamInterface $stream, PartBuilder $part)
+ {
+ $length = $part->getStreamContentLength();
+ if ($length !== 0) {
+ return $this->newLimitStream(
+ $stream,
+ $part->getStreamContentLength(),
+ $part->getStreamContentStartOffset()
+ );
+ }
+ return null;
+ }
+
+ /**
+ * Creates and returns a SeekingLimitedStream.
+ *
+ * @param StreamInterface $stream
+ * @param int $length
+ * @param int $start
+ * @return SeekingLimitStream
+ */
+ private function newLimitStream(StreamInterface $stream, $length, $start)
+ {
+ return new SeekingLimitStream(
+ $this->newNonClosingStream($stream),
+ $length,
+ $start
+ );
+ }
+
+ /**
+ * Creates a non-closing stream that doesn't close it's internal stream when
+ * closing/detaching.
+ *
+ * @param StreamInterface $stream
+ * @return NonClosingStream
+ */
+ public function newNonClosingStream(StreamInterface $stream)
+ {
+ return new NonClosingStream($stream);
+ }
+
+ /**
+ * Creates a ChunkSplitStream.
+ *
+ * @param StreamInterface $stream
+ * @return ChunkSplitStream
+ */
+ public function newChunkSplitStream(StreamInterface $stream)
+ {
+ return new ChunkSplitStream($stream);
+ }
+
+ /**
+ * Creates and returns a Base64Stream with an internal
+ * PregReplaceFilterStream that filters out non-base64 characters.
+ *
+ * @param StreamInterface $stream
+ * @return Base64Stream
+ */
+ public function newBase64Stream(StreamInterface $stream)
+ {
+ return new Base64Stream(
+ new PregReplaceFilterStream($stream, '/[^a-zA-Z0-9\/\+=]/', '')
+ );
+ }
+
+ /**
+ * Creates and returns a QuotedPrintableStream.
+ *
+ * @param StreamInterface $stream
+ * @return QuotedPrintableStream
+ */
+ public function newQuotedPrintableStream(StreamInterface $stream)
+ {
+ return new QuotedPrintableStream($stream);
+ }
+
+ /**
+ * Creates and returns a UUStream
+ *
+ * @param StreamInterface $stream
+ * @return UUStream
+ */
+ public function newUUStream(StreamInterface $stream)
+ {
+ return new UUStream($stream);
+ }
+
+ /**
+ * Creates and returns a CharsetStream
+ *
+ * @param StreamInterface $stream
+ * @param string $fromCharset
+ * @param string $toCharset
+ * @return CharsetStream
+ */
+ public function newCharsetStream(StreamInterface $stream, $fromCharset, $toCharset)
+ {
+ return new CharsetStream($stream, $fromCharset, $toCharset);
+ }
+
+ /**
+ * Creates and returns a MessagePartStream
+ *
+ * @param MessagePart $part
+ * @return MessagePartStream
+ */
+ public function newMessagePartStream(MessagePart $part)
+ {
+ return new MessagePartStream($this, $part);
+ }
+
+ /**
+ * Creates and returns a HeaderStream
+ *
+ * @param MessagePart $part
+ * @return HeaderStream
+ */
+ public function newHeaderStream(MessagePart $part)
+ {
+ return new HeaderStream($part);
+ }
+}
diff --git a/hdz/vendor/zbateson/mail-mime-parser/version.txt b/hdz/vendor/zbateson/mail-mime-parser/version.txt
new file mode 100644
index 0000000..f0bb29e
--- /dev/null
+++ b/hdz/vendor/zbateson/mail-mime-parser/version.txt
@@ -0,0 +1 @@
+1.3.0
diff --git a/hdz/vendor/zbateson/mb-wrapper/.github/FUNDING.yml b/hdz/vendor/zbateson/mb-wrapper/.github/FUNDING.yml
new file mode 100644
index 0000000..f137cf6
--- /dev/null
+++ b/hdz/vendor/zbateson/mb-wrapper/.github/FUNDING.yml
@@ -0,0 +1,3 @@
+# These are supported funding model platforms
+
+github: zbateson
diff --git a/hdz/vendor/zbateson/mb-wrapper/.gitignore b/hdz/vendor/zbateson/mb-wrapper/.gitignore
new file mode 100644
index 0000000..22d0d82
--- /dev/null
+++ b/hdz/vendor/zbateson/mb-wrapper/.gitignore
@@ -0,0 +1 @@
+vendor
diff --git a/hdz/vendor/zbateson/mb-wrapper/.travis.yml b/hdz/vendor/zbateson/mb-wrapper/.travis.yml
new file mode 100644
index 0000000..9b9fe78
--- /dev/null
+++ b/hdz/vendor/zbateson/mb-wrapper/.travis.yml
@@ -0,0 +1,20 @@
+language: php
+dist: trusty
+
+php:
+ - 5.4
+ - 5.5
+ - 5.6
+ - 7.0
+ - 7.1
+ - 7.2
+ - 7.3
+ - nightly
+matrix:
+ allow_failures:
+ - php: nightly
+
+install:
+ - composer update
+
+script: ./vendor/bin/phpunit -c tests/phpunit.xml
diff --git a/hdz/vendor/zbateson/mb-wrapper/LICENSE b/hdz/vendor/zbateson/mb-wrapper/LICENSE
new file mode 100644
index 0000000..3ba5af7
--- /dev/null
+++ b/hdz/vendor/zbateson/mb-wrapper/LICENSE
@@ -0,0 +1,25 @@
+BSD 2-Clause License
+
+Copyright (c) 2018, Zaahid Bateson
+All rights reserved.
+
+Redistribution and use in source and binary forms, with or without
+modification, are permitted provided that the following conditions are met:
+
+* Redistributions of source code must retain the above copyright notice, this
+ list of conditions and the following disclaimer.
+
+* 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.
+
+THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS"
+AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
+IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
+DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE LIABLE
+FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
+DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR
+SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER
+CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY,
+OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
+OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
diff --git a/hdz/vendor/zbateson/mb-wrapper/README.md b/hdz/vendor/zbateson/mb-wrapper/README.md
new file mode 100644
index 0000000..ef7a965
--- /dev/null
+++ b/hdz/vendor/zbateson/mb-wrapper/README.md
@@ -0,0 +1,61 @@
+# zbateson/mb-wrapper
+
+Charset conversion and string manipulation wrapper with a large defined set of aliases.
+
+[](https://travis-ci.org/zbateson/mb-wrapper)
+[](https://scrutinizer-ci.com/g/zbateson/mb-wrapper/?branch=master)
+[](https://scrutinizer-ci.com/g/zbateson/mb-wrapper/?branch=master)
+[](https://packagist.org/packages/zbateson/mb-wrapper)
+[](https://packagist.org/packages/zbateson/mb-wrapper)
+
+The goals of this project are to be:
+
+* Well written
+* Tested where possible
+* Support as wide a range of charset aliases as possible
+
+To include it for use in your project, please install via composer:
+
+```
+composer require zbateson/mb-wrapper
+```
+
+## Requirements
+
+mb-wrapper requires PHP 5.4 or newer. Tested on PHP 5.4, 5.5, 5.6, 7, 7.1, 7.2 and 7.3 on travis.
+
+Please note: hhvm support has been dropped as it no longer supports 'php' as of version 4. Previous versions of hhvm may still work, but are no longer supported.
+
+## Description
+
+MbWrapper is intended for use wherever mb_* or iconv_* is used. It scans supported charsets returned by mb_list_encodings(), and prefers mb_* functions, but will fallback to iconv if a charset isn't supported.
+
+A list of aliased charsets is maintained for both mb_* and iconv, where a supported charset exists for an alias. This is useful for mail and http parsing as other systems may report encodings not recognized by mb_* or iconv.
+
+Charset lookup is done by removing non-alphanumeric characters as well, so UTF8 will always be matched to UTF-8, etc...
+
+## Usage
+
+The following wrapper methods are exposed:
+* mb_convert_encoding, iconv with MbWrapper::convert
+* mb_substr, iconv_substr with MbWrapper::getSubstr
+* mb_strlen, iconv_strlen with MbWrapper::getLength
+* mb_check_encoding, iconv (for verification) with MbWrapper::checkEncoding
+
+```php
+$mbWrapper = new \ZBateson\MbWrapper\MbWrapper();
+$fromCharset = 'ISO-8859-1';
+$toCharset = 'UTF-8';
+
+$mbWrapper->convert('data', $fromCharset, $toCharset);
+$mbWrapper->getLength('data', 'UTF-8');
+$mbWrapper->substr('data', 'UTF-8', 1, 2);
+
+if ($mbWrapper->checkEncoding('data', 'UTF-8')) {
+ echo 'Compatible';
+}
+```
+
+## License
+
+BSD licensed - please see [license agreement](https://github.com/zbateson/mb-wrapper/blob/master/LICENSE).
diff --git a/hdz/vendor/zbateson/mb-wrapper/composer.json b/hdz/vendor/zbateson/mb-wrapper/composer.json
new file mode 100644
index 0000000..7c58880
--- /dev/null
+++ b/hdz/vendor/zbateson/mb-wrapper/composer.json
@@ -0,0 +1,33 @@
+{
+ "name": "zbateson/mb-wrapper",
+ "description": "Wrapper for mbstring with fallback to iconv for encoding conversion and string manipulation",
+ "keywords": ["mb_convert_encoding", "charset", "encoding", "string", "mbstring", "iconv", "multibyte", "mb", "mime", "mail", "http"],
+ "license": "BSD-2-Clause",
+ "authors": [
+ {
+ "name": "Zaahid Bateson"
+ }
+ ],
+ "require": {
+ "php": ">=5.4",
+ "symfony/polyfill-mbstring": "^1.9",
+ "symfony/polyfill-iconv": "^1.9"
+ },
+ "require-dev": {
+ "phpunit/phpunit": "^4.8 || ^5.7 || ^6.5"
+ },
+ "suggest": {
+ "ext-mbstring": "For best support/performance",
+ "ext-iconv": "For best support/performance"
+ },
+ "autoload": {
+ "psr-4": {
+ "ZBateson\\MbWrapper\\": "src/"
+ }
+ },
+ "autoload-dev": {
+ "psr-4": {
+ "ZBateson\\MbWrapper\\": "tests/MbWrapper"
+ }
+ }
+}
diff --git a/hdz/vendor/zbateson/mb-wrapper/composer.lock b/hdz/vendor/zbateson/mb-wrapper/composer.lock
new file mode 100644
index 0000000..d01e74e
--- /dev/null
+++ b/hdz/vendor/zbateson/mb-wrapper/composer.lock
@@ -0,0 +1,1733 @@
+{
+ "_readme": [
+ "This file locks the dependencies of your project to a known state",
+ "Read more about it at https://getcomposer.org/doc/01-basic-usage.md#installing-dependencies",
+ "This file is @generated automatically"
+ ],
+ "content-hash": "a37befb2926365cd4f1105718c4753e2",
+ "packages": [
+ {
+ "name": "symfony/polyfill-iconv",
+ "version": "v1.18.1",
+ "source": {
+ "type": "git",
+ "url": "https://github.com/symfony/polyfill-iconv.git",
+ "reference": "6c2f78eb8f5ab8eaea98f6d414a5915f2e0fce36"
+ },
+ "dist": {
+ "type": "zip",
+ "url": "https://api.github.com/repos/symfony/polyfill-iconv/zipball/6c2f78eb8f5ab8eaea98f6d414a5915f2e0fce36",
+ "reference": "6c2f78eb8f5ab8eaea98f6d414a5915f2e0fce36",
+ "shasum": ""
+ },
+ "require": {
+ "php": ">=5.3.3"
+ },
+ "suggest": {
+ "ext-iconv": "For best performance"
+ },
+ "type": "library",
+ "extra": {
+ "branch-alias": {
+ "dev-master": "1.18-dev"
+ },
+ "thanks": {
+ "name": "symfony/polyfill",
+ "url": "https://github.com/symfony/polyfill"
+ }
+ },
+ "autoload": {
+ "psr-4": {
+ "Symfony\\Polyfill\\Iconv\\": ""
+ },
+ "files": [
+ "bootstrap.php"
+ ]
+ },
+ "notification-url": "https://packagist.org/downloads/",
+ "license": [
+ "MIT"
+ ],
+ "authors": [
+ {
+ "name": "Nicolas Grekas",
+ "email": "p@tchwork.com"
+ },
+ {
+ "name": "Symfony Community",
+ "homepage": "https://symfony.com/contributors"
+ }
+ ],
+ "description": "Symfony polyfill for the Iconv extension",
+ "homepage": "https://symfony.com",
+ "keywords": [
+ "compatibility",
+ "iconv",
+ "polyfill",
+ "portable",
+ "shim"
+ ],
+ "funding": [
+ {
+ "url": "https://symfony.com/sponsor",
+ "type": "custom"
+ },
+ {
+ "url": "https://github.com/fabpot",
+ "type": "github"
+ },
+ {
+ "url": "https://tidelift.com/funding/github/packagist/symfony/symfony",
+ "type": "tidelift"
+ }
+ ],
+ "time": "2020-07-14T12:35:20+00:00"
+ },
+ {
+ "name": "symfony/polyfill-mbstring",
+ "version": "v1.18.1",
+ "source": {
+ "type": "git",
+ "url": "https://github.com/symfony/polyfill-mbstring.git",
+ "reference": "a6977d63bf9a0ad4c65cd352709e230876f9904a"
+ },
+ "dist": {
+ "type": "zip",
+ "url": "https://api.github.com/repos/symfony/polyfill-mbstring/zipball/a6977d63bf9a0ad4c65cd352709e230876f9904a",
+ "reference": "a6977d63bf9a0ad4c65cd352709e230876f9904a",
+ "shasum": ""
+ },
+ "require": {
+ "php": ">=5.3.3"
+ },
+ "suggest": {
+ "ext-mbstring": "For best performance"
+ },
+ "type": "library",
+ "extra": {
+ "branch-alias": {
+ "dev-master": "1.18-dev"
+ },
+ "thanks": {
+ "name": "symfony/polyfill",
+ "url": "https://github.com/symfony/polyfill"
+ }
+ },
+ "autoload": {
+ "psr-4": {
+ "Symfony\\Polyfill\\Mbstring\\": ""
+ },
+ "files": [
+ "bootstrap.php"
+ ]
+ },
+ "notification-url": "https://packagist.org/downloads/",
+ "license": [
+ "MIT"
+ ],
+ "authors": [
+ {
+ "name": "Nicolas Grekas",
+ "email": "p@tchwork.com"
+ },
+ {
+ "name": "Symfony Community",
+ "homepage": "https://symfony.com/contributors"
+ }
+ ],
+ "description": "Symfony polyfill for the Mbstring extension",
+ "homepage": "https://symfony.com",
+ "keywords": [
+ "compatibility",
+ "mbstring",
+ "polyfill",
+ "portable",
+ "shim"
+ ],
+ "funding": [
+ {
+ "url": "https://symfony.com/sponsor",
+ "type": "custom"
+ },
+ {
+ "url": "https://github.com/fabpot",
+ "type": "github"
+ },
+ {
+ "url": "https://tidelift.com/funding/github/packagist/symfony/symfony",
+ "type": "tidelift"
+ }
+ ],
+ "time": "2020-07-14T12:35:20+00:00"
+ }
+ ],
+ "packages-dev": [
+ {
+ "name": "doctrine/instantiator",
+ "version": "1.3.1",
+ "source": {
+ "type": "git",
+ "url": "https://github.com/doctrine/instantiator.git",
+ "reference": "f350df0268e904597e3bd9c4685c53e0e333feea"
+ },
+ "dist": {
+ "type": "zip",
+ "url": "https://api.github.com/repos/doctrine/instantiator/zipball/f350df0268e904597e3bd9c4685c53e0e333feea",
+ "reference": "f350df0268e904597e3bd9c4685c53e0e333feea",
+ "shasum": ""
+ },
+ "require": {
+ "php": "^7.1 || ^8.0"
+ },
+ "require-dev": {
+ "doctrine/coding-standard": "^6.0",
+ "ext-pdo": "*",
+ "ext-phar": "*",
+ "phpbench/phpbench": "^0.13",
+ "phpstan/phpstan-phpunit": "^0.11",
+ "phpstan/phpstan-shim": "^0.11",
+ "phpunit/phpunit": "^7.0"
+ },
+ "type": "library",
+ "extra": {
+ "branch-alias": {
+ "dev-master": "1.2.x-dev"
+ }
+ },
+ "autoload": {
+ "psr-4": {
+ "Doctrine\\Instantiator\\": "src/Doctrine/Instantiator/"
+ }
+ },
+ "notification-url": "https://packagist.org/downloads/",
+ "license": [
+ "MIT"
+ ],
+ "authors": [
+ {
+ "name": "Marco Pivetta",
+ "email": "ocramius@gmail.com",
+ "homepage": "http://ocramius.github.com/"
+ }
+ ],
+ "description": "A small, lightweight utility to instantiate objects in PHP without invoking their constructors",
+ "homepage": "https://www.doctrine-project.org/projects/instantiator.html",
+ "keywords": [
+ "constructor",
+ "instantiate"
+ ],
+ "funding": [
+ {
+ "url": "https://www.doctrine-project.org/sponsorship.html",
+ "type": "custom"
+ },
+ {
+ "url": "https://www.patreon.com/phpdoctrine",
+ "type": "patreon"
+ },
+ {
+ "url": "https://tidelift.com/funding/github/packagist/doctrine%2Finstantiator",
+ "type": "tidelift"
+ }
+ ],
+ "time": "2020-05-29T17:27:14+00:00"
+ },
+ {
+ "name": "myclabs/deep-copy",
+ "version": "1.10.1",
+ "source": {
+ "type": "git",
+ "url": "https://github.com/myclabs/DeepCopy.git",
+ "reference": "969b211f9a51aa1f6c01d1d2aef56d3bd91598e5"
+ },
+ "dist": {
+ "type": "zip",
+ "url": "https://api.github.com/repos/myclabs/DeepCopy/zipball/969b211f9a51aa1f6c01d1d2aef56d3bd91598e5",
+ "reference": "969b211f9a51aa1f6c01d1d2aef56d3bd91598e5",
+ "shasum": ""
+ },
+ "require": {
+ "php": "^7.1 || ^8.0"
+ },
+ "replace": {
+ "myclabs/deep-copy": "self.version"
+ },
+ "require-dev": {
+ "doctrine/collections": "^1.0",
+ "doctrine/common": "^2.6",
+ "phpunit/phpunit": "^7.1"
+ },
+ "type": "library",
+ "autoload": {
+ "psr-4": {
+ "DeepCopy\\": "src/DeepCopy/"
+ },
+ "files": [
+ "src/DeepCopy/deep_copy.php"
+ ]
+ },
+ "notification-url": "https://packagist.org/downloads/",
+ "license": [
+ "MIT"
+ ],
+ "description": "Create deep copies (clones) of your objects",
+ "keywords": [
+ "clone",
+ "copy",
+ "duplicate",
+ "object",
+ "object graph"
+ ],
+ "funding": [
+ {
+ "url": "https://tidelift.com/funding/github/packagist/myclabs/deep-copy",
+ "type": "tidelift"
+ }
+ ],
+ "time": "2020-06-29T13:22:24+00:00"
+ },
+ {
+ "name": "phar-io/manifest",
+ "version": "1.0.1",
+ "source": {
+ "type": "git",
+ "url": "https://github.com/phar-io/manifest.git",
+ "reference": "2df402786ab5368a0169091f61a7c1e0eb6852d0"
+ },
+ "dist": {
+ "type": "zip",
+ "url": "https://api.github.com/repos/phar-io/manifest/zipball/2df402786ab5368a0169091f61a7c1e0eb6852d0",
+ "reference": "2df402786ab5368a0169091f61a7c1e0eb6852d0",
+ "shasum": ""
+ },
+ "require": {
+ "ext-dom": "*",
+ "ext-phar": "*",
+ "phar-io/version": "^1.0.1",
+ "php": "^5.6 || ^7.0"
+ },
+ "type": "library",
+ "extra": {
+ "branch-alias": {
+ "dev-master": "1.0.x-dev"
+ }
+ },
+ "autoload": {
+ "classmap": [
+ "src/"
+ ]
+ },
+ "notification-url": "https://packagist.org/downloads/",
+ "license": [
+ "BSD-3-Clause"
+ ],
+ "authors": [
+ {
+ "name": "Arne Blankerts",
+ "email": "arne@blankerts.de",
+ "role": "Developer"
+ },
+ {
+ "name": "Sebastian Heuer",
+ "email": "sebastian@phpeople.de",
+ "role": "Developer"
+ },
+ {
+ "name": "Sebastian Bergmann",
+ "email": "sebastian@phpunit.de",
+ "role": "Developer"
+ }
+ ],
+ "description": "Component for reading phar.io manifest information from a PHP Archive (PHAR)",
+ "time": "2017-03-05T18:14:27+00:00"
+ },
+ {
+ "name": "phar-io/version",
+ "version": "1.0.1",
+ "source": {
+ "type": "git",
+ "url": "https://github.com/phar-io/version.git",
+ "reference": "a70c0ced4be299a63d32fa96d9281d03e94041df"
+ },
+ "dist": {
+ "type": "zip",
+ "url": "https://api.github.com/repos/phar-io/version/zipball/a70c0ced4be299a63d32fa96d9281d03e94041df",
+ "reference": "a70c0ced4be299a63d32fa96d9281d03e94041df",
+ "shasum": ""
+ },
+ "require": {
+ "php": "^5.6 || ^7.0"
+ },
+ "type": "library",
+ "autoload": {
+ "classmap": [
+ "src/"
+ ]
+ },
+ "notification-url": "https://packagist.org/downloads/",
+ "license": [
+ "BSD-3-Clause"
+ ],
+ "authors": [
+ {
+ "name": "Arne Blankerts",
+ "email": "arne@blankerts.de",
+ "role": "Developer"
+ },
+ {
+ "name": "Sebastian Heuer",
+ "email": "sebastian@phpeople.de",
+ "role": "Developer"
+ },
+ {
+ "name": "Sebastian Bergmann",
+ "email": "sebastian@phpunit.de",
+ "role": "Developer"
+ }
+ ],
+ "description": "Library for handling version information and constraints",
+ "time": "2017-03-05T17:38:23+00:00"
+ },
+ {
+ "name": "phpdocumentor/reflection-common",
+ "version": "2.2.0",
+ "source": {
+ "type": "git",
+ "url": "https://github.com/phpDocumentor/ReflectionCommon.git",
+ "reference": "1d01c49d4ed62f25aa84a747ad35d5a16924662b"
+ },
+ "dist": {
+ "type": "zip",
+ "url": "https://api.github.com/repos/phpDocumentor/ReflectionCommon/zipball/1d01c49d4ed62f25aa84a747ad35d5a16924662b",
+ "reference": "1d01c49d4ed62f25aa84a747ad35d5a16924662b",
+ "shasum": ""
+ },
+ "require": {
+ "php": "^7.2 || ^8.0"
+ },
+ "type": "library",
+ "extra": {
+ "branch-alias": {
+ "dev-2.x": "2.x-dev"
+ }
+ },
+ "autoload": {
+ "psr-4": {
+ "phpDocumentor\\Reflection\\": "src/"
+ }
+ },
+ "notification-url": "https://packagist.org/downloads/",
+ "license": [
+ "MIT"
+ ],
+ "authors": [
+ {
+ "name": "Jaap van Otterdijk",
+ "email": "opensource@ijaap.nl"
+ }
+ ],
+ "description": "Common reflection classes used by phpdocumentor to reflect the code structure",
+ "homepage": "http://www.phpdoc.org",
+ "keywords": [
+ "FQSEN",
+ "phpDocumentor",
+ "phpdoc",
+ "reflection",
+ "static analysis"
+ ],
+ "time": "2020-06-27T09:03:43+00:00"
+ },
+ {
+ "name": "phpdocumentor/reflection-docblock",
+ "version": "5.2.2",
+ "source": {
+ "type": "git",
+ "url": "https://github.com/phpDocumentor/ReflectionDocBlock.git",
+ "reference": "069a785b2141f5bcf49f3e353548dc1cce6df556"
+ },
+ "dist": {
+ "type": "zip",
+ "url": "https://api.github.com/repos/phpDocumentor/ReflectionDocBlock/zipball/069a785b2141f5bcf49f3e353548dc1cce6df556",
+ "reference": "069a785b2141f5bcf49f3e353548dc1cce6df556",
+ "shasum": ""
+ },
+ "require": {
+ "ext-filter": "*",
+ "php": "^7.2 || ^8.0",
+ "phpdocumentor/reflection-common": "^2.2",
+ "phpdocumentor/type-resolver": "^1.3",
+ "webmozart/assert": "^1.9.1"
+ },
+ "require-dev": {
+ "mockery/mockery": "~1.3.2"
+ },
+ "type": "library",
+ "extra": {
+ "branch-alias": {
+ "dev-master": "5.x-dev"
+ }
+ },
+ "autoload": {
+ "psr-4": {
+ "phpDocumentor\\Reflection\\": "src"
+ }
+ },
+ "notification-url": "https://packagist.org/downloads/",
+ "license": [
+ "MIT"
+ ],
+ "authors": [
+ {
+ "name": "Mike van Riel",
+ "email": "me@mikevanriel.com"
+ },
+ {
+ "name": "Jaap van Otterdijk",
+ "email": "account@ijaap.nl"
+ }
+ ],
+ "description": "With this component, a library can provide support for annotations via DocBlocks or otherwise retrieve information that is embedded in a DocBlock.",
+ "time": "2020-09-03T19:13:55+00:00"
+ },
+ {
+ "name": "phpdocumentor/type-resolver",
+ "version": "1.4.0",
+ "source": {
+ "type": "git",
+ "url": "https://github.com/phpDocumentor/TypeResolver.git",
+ "reference": "6a467b8989322d92aa1c8bf2bebcc6e5c2ba55c0"
+ },
+ "dist": {
+ "type": "zip",
+ "url": "https://api.github.com/repos/phpDocumentor/TypeResolver/zipball/6a467b8989322d92aa1c8bf2bebcc6e5c2ba55c0",
+ "reference": "6a467b8989322d92aa1c8bf2bebcc6e5c2ba55c0",
+ "shasum": ""
+ },
+ "require": {
+ "php": "^7.2 || ^8.0",
+ "phpdocumentor/reflection-common": "^2.0"
+ },
+ "require-dev": {
+ "ext-tokenizer": "*"
+ },
+ "type": "library",
+ "extra": {
+ "branch-alias": {
+ "dev-1.x": "1.x-dev"
+ }
+ },
+ "autoload": {
+ "psr-4": {
+ "phpDocumentor\\Reflection\\": "src"
+ }
+ },
+ "notification-url": "https://packagist.org/downloads/",
+ "license": [
+ "MIT"
+ ],
+ "authors": [
+ {
+ "name": "Mike van Riel",
+ "email": "me@mikevanriel.com"
+ }
+ ],
+ "description": "A PSR-5 based resolver of Class names, Types and Structural Element Names",
+ "time": "2020-09-17T18:55:26+00:00"
+ },
+ {
+ "name": "phpspec/prophecy",
+ "version": "v1.10.3",
+ "source": {
+ "type": "git",
+ "url": "https://github.com/phpspec/prophecy.git",
+ "reference": "451c3cd1418cf640de218914901e51b064abb093"
+ },
+ "dist": {
+ "type": "zip",
+ "url": "https://api.github.com/repos/phpspec/prophecy/zipball/451c3cd1418cf640de218914901e51b064abb093",
+ "reference": "451c3cd1418cf640de218914901e51b064abb093",
+ "shasum": ""
+ },
+ "require": {
+ "doctrine/instantiator": "^1.0.2",
+ "php": "^5.3|^7.0",
+ "phpdocumentor/reflection-docblock": "^2.0|^3.0.2|^4.0|^5.0",
+ "sebastian/comparator": "^1.2.3|^2.0|^3.0|^4.0",
+ "sebastian/recursion-context": "^1.0|^2.0|^3.0|^4.0"
+ },
+ "require-dev": {
+ "phpspec/phpspec": "^2.5 || ^3.2",
+ "phpunit/phpunit": "^4.8.35 || ^5.7 || ^6.5 || ^7.1"
+ },
+ "type": "library",
+ "extra": {
+ "branch-alias": {
+ "dev-master": "1.10.x-dev"
+ }
+ },
+ "autoload": {
+ "psr-4": {
+ "Prophecy\\": "src/Prophecy"
+ }
+ },
+ "notification-url": "https://packagist.org/downloads/",
+ "license": [
+ "MIT"
+ ],
+ "authors": [
+ {
+ "name": "Konstantin Kudryashov",
+ "email": "ever.zet@gmail.com",
+ "homepage": "http://everzet.com"
+ },
+ {
+ "name": "Marcello Duarte",
+ "email": "marcello.duarte@gmail.com"
+ }
+ ],
+ "description": "Highly opinionated mocking framework for PHP 5.3+",
+ "homepage": "https://github.com/phpspec/prophecy",
+ "keywords": [
+ "Double",
+ "Dummy",
+ "fake",
+ "mock",
+ "spy",
+ "stub"
+ ],
+ "time": "2020-03-05T15:02:03+00:00"
+ },
+ {
+ "name": "phpunit/php-code-coverage",
+ "version": "5.3.2",
+ "source": {
+ "type": "git",
+ "url": "https://github.com/sebastianbergmann/php-code-coverage.git",
+ "reference": "c89677919c5dd6d3b3852f230a663118762218ac"
+ },
+ "dist": {
+ "type": "zip",
+ "url": "https://api.github.com/repos/sebastianbergmann/php-code-coverage/zipball/c89677919c5dd6d3b3852f230a663118762218ac",
+ "reference": "c89677919c5dd6d3b3852f230a663118762218ac",
+ "shasum": ""
+ },
+ "require": {
+ "ext-dom": "*",
+ "ext-xmlwriter": "*",
+ "php": "^7.0",
+ "phpunit/php-file-iterator": "^1.4.2",
+ "phpunit/php-text-template": "^1.2.1",
+ "phpunit/php-token-stream": "^2.0.1",
+ "sebastian/code-unit-reverse-lookup": "^1.0.1",
+ "sebastian/environment": "^3.0",
+ "sebastian/version": "^2.0.1",
+ "theseer/tokenizer": "^1.1"
+ },
+ "require-dev": {
+ "phpunit/phpunit": "^6.0"
+ },
+ "suggest": {
+ "ext-xdebug": "^2.5.5"
+ },
+ "type": "library",
+ "extra": {
+ "branch-alias": {
+ "dev-master": "5.3.x-dev"
+ }
+ },
+ "autoload": {
+ "classmap": [
+ "src/"
+ ]
+ },
+ "notification-url": "https://packagist.org/downloads/",
+ "license": [
+ "BSD-3-Clause"
+ ],
+ "authors": [
+ {
+ "name": "Sebastian Bergmann",
+ "email": "sebastian@phpunit.de",
+ "role": "lead"
+ }
+ ],
+ "description": "Library that provides collection, processing, and rendering functionality for PHP code coverage information.",
+ "homepage": "https://github.com/sebastianbergmann/php-code-coverage",
+ "keywords": [
+ "coverage",
+ "testing",
+ "xunit"
+ ],
+ "time": "2018-04-06T15:36:58+00:00"
+ },
+ {
+ "name": "phpunit/php-file-iterator",
+ "version": "1.4.5",
+ "source": {
+ "type": "git",
+ "url": "https://github.com/sebastianbergmann/php-file-iterator.git",
+ "reference": "730b01bc3e867237eaac355e06a36b85dd93a8b4"
+ },
+ "dist": {
+ "type": "zip",
+ "url": "https://api.github.com/repos/sebastianbergmann/php-file-iterator/zipball/730b01bc3e867237eaac355e06a36b85dd93a8b4",
+ "reference": "730b01bc3e867237eaac355e06a36b85dd93a8b4",
+ "shasum": ""
+ },
+ "require": {
+ "php": ">=5.3.3"
+ },
+ "type": "library",
+ "extra": {
+ "branch-alias": {
+ "dev-master": "1.4.x-dev"
+ }
+ },
+ "autoload": {
+ "classmap": [
+ "src/"
+ ]
+ },
+ "notification-url": "https://packagist.org/downloads/",
+ "license": [
+ "BSD-3-Clause"
+ ],
+ "authors": [
+ {
+ "name": "Sebastian Bergmann",
+ "email": "sb@sebastian-bergmann.de",
+ "role": "lead"
+ }
+ ],
+ "description": "FilterIterator implementation that filters files based on a list of suffixes.",
+ "homepage": "https://github.com/sebastianbergmann/php-file-iterator/",
+ "keywords": [
+ "filesystem",
+ "iterator"
+ ],
+ "time": "2017-11-27T13:52:08+00:00"
+ },
+ {
+ "name": "phpunit/php-text-template",
+ "version": "1.2.1",
+ "source": {
+ "type": "git",
+ "url": "https://github.com/sebastianbergmann/php-text-template.git",
+ "reference": "31f8b717e51d9a2afca6c9f046f5d69fc27c8686"
+ },
+ "dist": {
+ "type": "zip",
+ "url": "https://api.github.com/repos/sebastianbergmann/php-text-template/zipball/31f8b717e51d9a2afca6c9f046f5d69fc27c8686",
+ "reference": "31f8b717e51d9a2afca6c9f046f5d69fc27c8686",
+ "shasum": ""
+ },
+ "require": {
+ "php": ">=5.3.3"
+ },
+ "type": "library",
+ "autoload": {
+ "classmap": [
+ "src/"
+ ]
+ },
+ "notification-url": "https://packagist.org/downloads/",
+ "license": [
+ "BSD-3-Clause"
+ ],
+ "authors": [
+ {
+ "name": "Sebastian Bergmann",
+ "email": "sebastian@phpunit.de",
+ "role": "lead"
+ }
+ ],
+ "description": "Simple template engine.",
+ "homepage": "https://github.com/sebastianbergmann/php-text-template/",
+ "keywords": [
+ "template"
+ ],
+ "time": "2015-06-21T13:50:34+00:00"
+ },
+ {
+ "name": "phpunit/php-timer",
+ "version": "1.0.9",
+ "source": {
+ "type": "git",
+ "url": "https://github.com/sebastianbergmann/php-timer.git",
+ "reference": "3dcf38ca72b158baf0bc245e9184d3fdffa9c46f"
+ },
+ "dist": {
+ "type": "zip",
+ "url": "https://api.github.com/repos/sebastianbergmann/php-timer/zipball/3dcf38ca72b158baf0bc245e9184d3fdffa9c46f",
+ "reference": "3dcf38ca72b158baf0bc245e9184d3fdffa9c46f",
+ "shasum": ""
+ },
+ "require": {
+ "php": "^5.3.3 || ^7.0"
+ },
+ "require-dev": {
+ "phpunit/phpunit": "^4.8.35 || ^5.7 || ^6.0"
+ },
+ "type": "library",
+ "extra": {
+ "branch-alias": {
+ "dev-master": "1.0-dev"
+ }
+ },
+ "autoload": {
+ "classmap": [
+ "src/"
+ ]
+ },
+ "notification-url": "https://packagist.org/downloads/",
+ "license": [
+ "BSD-3-Clause"
+ ],
+ "authors": [
+ {
+ "name": "Sebastian Bergmann",
+ "email": "sb@sebastian-bergmann.de",
+ "role": "lead"
+ }
+ ],
+ "description": "Utility class for timing",
+ "homepage": "https://github.com/sebastianbergmann/php-timer/",
+ "keywords": [
+ "timer"
+ ],
+ "time": "2017-02-26T11:10:40+00:00"
+ },
+ {
+ "name": "phpunit/php-token-stream",
+ "version": "2.0.2",
+ "source": {
+ "type": "git",
+ "url": "https://github.com/sebastianbergmann/php-token-stream.git",
+ "reference": "791198a2c6254db10131eecfe8c06670700904db"
+ },
+ "dist": {
+ "type": "zip",
+ "url": "https://api.github.com/repos/sebastianbergmann/php-token-stream/zipball/791198a2c6254db10131eecfe8c06670700904db",
+ "reference": "791198a2c6254db10131eecfe8c06670700904db",
+ "shasum": ""
+ },
+ "require": {
+ "ext-tokenizer": "*",
+ "php": "^7.0"
+ },
+ "require-dev": {
+ "phpunit/phpunit": "^6.2.4"
+ },
+ "type": "library",
+ "extra": {
+ "branch-alias": {
+ "dev-master": "2.0-dev"
+ }
+ },
+ "autoload": {
+ "classmap": [
+ "src/"
+ ]
+ },
+ "notification-url": "https://packagist.org/downloads/",
+ "license": [
+ "BSD-3-Clause"
+ ],
+ "authors": [
+ {
+ "name": "Sebastian Bergmann",
+ "email": "sebastian@phpunit.de"
+ }
+ ],
+ "description": "Wrapper around PHP's tokenizer extension.",
+ "homepage": "https://github.com/sebastianbergmann/php-token-stream/",
+ "keywords": [
+ "tokenizer"
+ ],
+ "time": "2017-11-27T05:48:46+00:00"
+ },
+ {
+ "name": "phpunit/phpunit",
+ "version": "6.5.14",
+ "source": {
+ "type": "git",
+ "url": "https://github.com/sebastianbergmann/phpunit.git",
+ "reference": "bac23fe7ff13dbdb461481f706f0e9fe746334b7"
+ },
+ "dist": {
+ "type": "zip",
+ "url": "https://api.github.com/repos/sebastianbergmann/phpunit/zipball/bac23fe7ff13dbdb461481f706f0e9fe746334b7",
+ "reference": "bac23fe7ff13dbdb461481f706f0e9fe746334b7",
+ "shasum": ""
+ },
+ "require": {
+ "ext-dom": "*",
+ "ext-json": "*",
+ "ext-libxml": "*",
+ "ext-mbstring": "*",
+ "ext-xml": "*",
+ "myclabs/deep-copy": "^1.6.1",
+ "phar-io/manifest": "^1.0.1",
+ "phar-io/version": "^1.0",
+ "php": "^7.0",
+ "phpspec/prophecy": "^1.7",
+ "phpunit/php-code-coverage": "^5.3",
+ "phpunit/php-file-iterator": "^1.4.3",
+ "phpunit/php-text-template": "^1.2.1",
+ "phpunit/php-timer": "^1.0.9",
+ "phpunit/phpunit-mock-objects": "^5.0.9",
+ "sebastian/comparator": "^2.1",
+ "sebastian/diff": "^2.0",
+ "sebastian/environment": "^3.1",
+ "sebastian/exporter": "^3.1",
+ "sebastian/global-state": "^2.0",
+ "sebastian/object-enumerator": "^3.0.3",
+ "sebastian/resource-operations": "^1.0",
+ "sebastian/version": "^2.0.1"
+ },
+ "conflict": {
+ "phpdocumentor/reflection-docblock": "3.0.2",
+ "phpunit/dbunit": "<3.0"
+ },
+ "require-dev": {
+ "ext-pdo": "*"
+ },
+ "suggest": {
+ "ext-xdebug": "*",
+ "phpunit/php-invoker": "^1.1"
+ },
+ "bin": [
+ "phpunit"
+ ],
+ "type": "library",
+ "extra": {
+ "branch-alias": {
+ "dev-master": "6.5.x-dev"
+ }
+ },
+ "autoload": {
+ "classmap": [
+ "src/"
+ ]
+ },
+ "notification-url": "https://packagist.org/downloads/",
+ "license": [
+ "BSD-3-Clause"
+ ],
+ "authors": [
+ {
+ "name": "Sebastian Bergmann",
+ "email": "sebastian@phpunit.de",
+ "role": "lead"
+ }
+ ],
+ "description": "The PHP Unit Testing framework.",
+ "homepage": "https://phpunit.de/",
+ "keywords": [
+ "phpunit",
+ "testing",
+ "xunit"
+ ],
+ "time": "2019-02-01T05:22:47+00:00"
+ },
+ {
+ "name": "phpunit/phpunit-mock-objects",
+ "version": "5.0.10",
+ "source": {
+ "type": "git",
+ "url": "https://github.com/sebastianbergmann/phpunit-mock-objects.git",
+ "reference": "cd1cf05c553ecfec36b170070573e540b67d3f1f"
+ },
+ "dist": {
+ "type": "zip",
+ "url": "https://api.github.com/repos/sebastianbergmann/phpunit-mock-objects/zipball/cd1cf05c553ecfec36b170070573e540b67d3f1f",
+ "reference": "cd1cf05c553ecfec36b170070573e540b67d3f1f",
+ "shasum": ""
+ },
+ "require": {
+ "doctrine/instantiator": "^1.0.5",
+ "php": "^7.0",
+ "phpunit/php-text-template": "^1.2.1",
+ "sebastian/exporter": "^3.1"
+ },
+ "conflict": {
+ "phpunit/phpunit": "<6.0"
+ },
+ "require-dev": {
+ "phpunit/phpunit": "^6.5.11"
+ },
+ "suggest": {
+ "ext-soap": "*"
+ },
+ "type": "library",
+ "extra": {
+ "branch-alias": {
+ "dev-master": "5.0.x-dev"
+ }
+ },
+ "autoload": {
+ "classmap": [
+ "src/"
+ ]
+ },
+ "notification-url": "https://packagist.org/downloads/",
+ "license": [
+ "BSD-3-Clause"
+ ],
+ "authors": [
+ {
+ "name": "Sebastian Bergmann",
+ "email": "sebastian@phpunit.de",
+ "role": "lead"
+ }
+ ],
+ "description": "Mock Object library for PHPUnit",
+ "homepage": "https://github.com/sebastianbergmann/phpunit-mock-objects/",
+ "keywords": [
+ "mock",
+ "xunit"
+ ],
+ "time": "2018-08-09T05:50:03+00:00"
+ },
+ {
+ "name": "sebastian/code-unit-reverse-lookup",
+ "version": "1.0.1",
+ "source": {
+ "type": "git",
+ "url": "https://github.com/sebastianbergmann/code-unit-reverse-lookup.git",
+ "reference": "4419fcdb5eabb9caa61a27c7a1db532a6b55dd18"
+ },
+ "dist": {
+ "type": "zip",
+ "url": "https://api.github.com/repos/sebastianbergmann/code-unit-reverse-lookup/zipball/4419fcdb5eabb9caa61a27c7a1db532a6b55dd18",
+ "reference": "4419fcdb5eabb9caa61a27c7a1db532a6b55dd18",
+ "shasum": ""
+ },
+ "require": {
+ "php": "^5.6 || ^7.0"
+ },
+ "require-dev": {
+ "phpunit/phpunit": "^5.7 || ^6.0"
+ },
+ "type": "library",
+ "extra": {
+ "branch-alias": {
+ "dev-master": "1.0.x-dev"
+ }
+ },
+ "autoload": {
+ "classmap": [
+ "src/"
+ ]
+ },
+ "notification-url": "https://packagist.org/downloads/",
+ "license": [
+ "BSD-3-Clause"
+ ],
+ "authors": [
+ {
+ "name": "Sebastian Bergmann",
+ "email": "sebastian@phpunit.de"
+ }
+ ],
+ "description": "Looks up which function or method a line of code belongs to",
+ "homepage": "https://github.com/sebastianbergmann/code-unit-reverse-lookup/",
+ "time": "2017-03-04T06:30:41+00:00"
+ },
+ {
+ "name": "sebastian/comparator",
+ "version": "2.1.3",
+ "source": {
+ "type": "git",
+ "url": "https://github.com/sebastianbergmann/comparator.git",
+ "reference": "34369daee48eafb2651bea869b4b15d75ccc35f9"
+ },
+ "dist": {
+ "type": "zip",
+ "url": "https://api.github.com/repos/sebastianbergmann/comparator/zipball/34369daee48eafb2651bea869b4b15d75ccc35f9",
+ "reference": "34369daee48eafb2651bea869b4b15d75ccc35f9",
+ "shasum": ""
+ },
+ "require": {
+ "php": "^7.0",
+ "sebastian/diff": "^2.0 || ^3.0",
+ "sebastian/exporter": "^3.1"
+ },
+ "require-dev": {
+ "phpunit/phpunit": "^6.4"
+ },
+ "type": "library",
+ "extra": {
+ "branch-alias": {
+ "dev-master": "2.1.x-dev"
+ }
+ },
+ "autoload": {
+ "classmap": [
+ "src/"
+ ]
+ },
+ "notification-url": "https://packagist.org/downloads/",
+ "license": [
+ "BSD-3-Clause"
+ ],
+ "authors": [
+ {
+ "name": "Jeff Welch",
+ "email": "whatthejeff@gmail.com"
+ },
+ {
+ "name": "Volker Dusch",
+ "email": "github@wallbash.com"
+ },
+ {
+ "name": "Bernhard Schussek",
+ "email": "bschussek@2bepublished.at"
+ },
+ {
+ "name": "Sebastian Bergmann",
+ "email": "sebastian@phpunit.de"
+ }
+ ],
+ "description": "Provides the functionality to compare PHP values for equality",
+ "homepage": "https://github.com/sebastianbergmann/comparator",
+ "keywords": [
+ "comparator",
+ "compare",
+ "equality"
+ ],
+ "time": "2018-02-01T13:46:46+00:00"
+ },
+ {
+ "name": "sebastian/diff",
+ "version": "2.0.1",
+ "source": {
+ "type": "git",
+ "url": "https://github.com/sebastianbergmann/diff.git",
+ "reference": "347c1d8b49c5c3ee30c7040ea6fc446790e6bddd"
+ },
+ "dist": {
+ "type": "zip",
+ "url": "https://api.github.com/repos/sebastianbergmann/diff/zipball/347c1d8b49c5c3ee30c7040ea6fc446790e6bddd",
+ "reference": "347c1d8b49c5c3ee30c7040ea6fc446790e6bddd",
+ "shasum": ""
+ },
+ "require": {
+ "php": "^7.0"
+ },
+ "require-dev": {
+ "phpunit/phpunit": "^6.2"
+ },
+ "type": "library",
+ "extra": {
+ "branch-alias": {
+ "dev-master": "2.0-dev"
+ }
+ },
+ "autoload": {
+ "classmap": [
+ "src/"
+ ]
+ },
+ "notification-url": "https://packagist.org/downloads/",
+ "license": [
+ "BSD-3-Clause"
+ ],
+ "authors": [
+ {
+ "name": "Kore Nordmann",
+ "email": "mail@kore-nordmann.de"
+ },
+ {
+ "name": "Sebastian Bergmann",
+ "email": "sebastian@phpunit.de"
+ }
+ ],
+ "description": "Diff implementation",
+ "homepage": "https://github.com/sebastianbergmann/diff",
+ "keywords": [
+ "diff"
+ ],
+ "time": "2017-08-03T08:09:46+00:00"
+ },
+ {
+ "name": "sebastian/environment",
+ "version": "3.1.0",
+ "source": {
+ "type": "git",
+ "url": "https://github.com/sebastianbergmann/environment.git",
+ "reference": "cd0871b3975fb7fc44d11314fd1ee20925fce4f5"
+ },
+ "dist": {
+ "type": "zip",
+ "url": "https://api.github.com/repos/sebastianbergmann/environment/zipball/cd0871b3975fb7fc44d11314fd1ee20925fce4f5",
+ "reference": "cd0871b3975fb7fc44d11314fd1ee20925fce4f5",
+ "shasum": ""
+ },
+ "require": {
+ "php": "^7.0"
+ },
+ "require-dev": {
+ "phpunit/phpunit": "^6.1"
+ },
+ "type": "library",
+ "extra": {
+ "branch-alias": {
+ "dev-master": "3.1.x-dev"
+ }
+ },
+ "autoload": {
+ "classmap": [
+ "src/"
+ ]
+ },
+ "notification-url": "https://packagist.org/downloads/",
+ "license": [
+ "BSD-3-Clause"
+ ],
+ "authors": [
+ {
+ "name": "Sebastian Bergmann",
+ "email": "sebastian@phpunit.de"
+ }
+ ],
+ "description": "Provides functionality to handle HHVM/PHP environments",
+ "homepage": "http://www.github.com/sebastianbergmann/environment",
+ "keywords": [
+ "Xdebug",
+ "environment",
+ "hhvm"
+ ],
+ "time": "2017-07-01T08:51:00+00:00"
+ },
+ {
+ "name": "sebastian/exporter",
+ "version": "3.1.2",
+ "source": {
+ "type": "git",
+ "url": "https://github.com/sebastianbergmann/exporter.git",
+ "reference": "68609e1261d215ea5b21b7987539cbfbe156ec3e"
+ },
+ "dist": {
+ "type": "zip",
+ "url": "https://api.github.com/repos/sebastianbergmann/exporter/zipball/68609e1261d215ea5b21b7987539cbfbe156ec3e",
+ "reference": "68609e1261d215ea5b21b7987539cbfbe156ec3e",
+ "shasum": ""
+ },
+ "require": {
+ "php": "^7.0",
+ "sebastian/recursion-context": "^3.0"
+ },
+ "require-dev": {
+ "ext-mbstring": "*",
+ "phpunit/phpunit": "^6.0"
+ },
+ "type": "library",
+ "extra": {
+ "branch-alias": {
+ "dev-master": "3.1.x-dev"
+ }
+ },
+ "autoload": {
+ "classmap": [
+ "src/"
+ ]
+ },
+ "notification-url": "https://packagist.org/downloads/",
+ "license": [
+ "BSD-3-Clause"
+ ],
+ "authors": [
+ {
+ "name": "Sebastian Bergmann",
+ "email": "sebastian@phpunit.de"
+ },
+ {
+ "name": "Jeff Welch",
+ "email": "whatthejeff@gmail.com"
+ },
+ {
+ "name": "Volker Dusch",
+ "email": "github@wallbash.com"
+ },
+ {
+ "name": "Adam Harvey",
+ "email": "aharvey@php.net"
+ },
+ {
+ "name": "Bernhard Schussek",
+ "email": "bschussek@gmail.com"
+ }
+ ],
+ "description": "Provides the functionality to export PHP variables for visualization",
+ "homepage": "http://www.github.com/sebastianbergmann/exporter",
+ "keywords": [
+ "export",
+ "exporter"
+ ],
+ "time": "2019-09-14T09:02:43+00:00"
+ },
+ {
+ "name": "sebastian/global-state",
+ "version": "2.0.0",
+ "source": {
+ "type": "git",
+ "url": "https://github.com/sebastianbergmann/global-state.git",
+ "reference": "e8ba02eed7bbbb9e59e43dedd3dddeff4a56b0c4"
+ },
+ "dist": {
+ "type": "zip",
+ "url": "https://api.github.com/repos/sebastianbergmann/global-state/zipball/e8ba02eed7bbbb9e59e43dedd3dddeff4a56b0c4",
+ "reference": "e8ba02eed7bbbb9e59e43dedd3dddeff4a56b0c4",
+ "shasum": ""
+ },
+ "require": {
+ "php": "^7.0"
+ },
+ "require-dev": {
+ "phpunit/phpunit": "^6.0"
+ },
+ "suggest": {
+ "ext-uopz": "*"
+ },
+ "type": "library",
+ "extra": {
+ "branch-alias": {
+ "dev-master": "2.0-dev"
+ }
+ },
+ "autoload": {
+ "classmap": [
+ "src/"
+ ]
+ },
+ "notification-url": "https://packagist.org/downloads/",
+ "license": [
+ "BSD-3-Clause"
+ ],
+ "authors": [
+ {
+ "name": "Sebastian Bergmann",
+ "email": "sebastian@phpunit.de"
+ }
+ ],
+ "description": "Snapshotting of global state",
+ "homepage": "http://www.github.com/sebastianbergmann/global-state",
+ "keywords": [
+ "global state"
+ ],
+ "time": "2017-04-27T15:39:26+00:00"
+ },
+ {
+ "name": "sebastian/object-enumerator",
+ "version": "3.0.3",
+ "source": {
+ "type": "git",
+ "url": "https://github.com/sebastianbergmann/object-enumerator.git",
+ "reference": "7cfd9e65d11ffb5af41198476395774d4c8a84c5"
+ },
+ "dist": {
+ "type": "zip",
+ "url": "https://api.github.com/repos/sebastianbergmann/object-enumerator/zipball/7cfd9e65d11ffb5af41198476395774d4c8a84c5",
+ "reference": "7cfd9e65d11ffb5af41198476395774d4c8a84c5",
+ "shasum": ""
+ },
+ "require": {
+ "php": "^7.0",
+ "sebastian/object-reflector": "^1.1.1",
+ "sebastian/recursion-context": "^3.0"
+ },
+ "require-dev": {
+ "phpunit/phpunit": "^6.0"
+ },
+ "type": "library",
+ "extra": {
+ "branch-alias": {
+ "dev-master": "3.0.x-dev"
+ }
+ },
+ "autoload": {
+ "classmap": [
+ "src/"
+ ]
+ },
+ "notification-url": "https://packagist.org/downloads/",
+ "license": [
+ "BSD-3-Clause"
+ ],
+ "authors": [
+ {
+ "name": "Sebastian Bergmann",
+ "email": "sebastian@phpunit.de"
+ }
+ ],
+ "description": "Traverses array structures and object graphs to enumerate all referenced objects",
+ "homepage": "https://github.com/sebastianbergmann/object-enumerator/",
+ "time": "2017-08-03T12:35:26+00:00"
+ },
+ {
+ "name": "sebastian/object-reflector",
+ "version": "1.1.1",
+ "source": {
+ "type": "git",
+ "url": "https://github.com/sebastianbergmann/object-reflector.git",
+ "reference": "773f97c67f28de00d397be301821b06708fca0be"
+ },
+ "dist": {
+ "type": "zip",
+ "url": "https://api.github.com/repos/sebastianbergmann/object-reflector/zipball/773f97c67f28de00d397be301821b06708fca0be",
+ "reference": "773f97c67f28de00d397be301821b06708fca0be",
+ "shasum": ""
+ },
+ "require": {
+ "php": "^7.0"
+ },
+ "require-dev": {
+ "phpunit/phpunit": "^6.0"
+ },
+ "type": "library",
+ "extra": {
+ "branch-alias": {
+ "dev-master": "1.1-dev"
+ }
+ },
+ "autoload": {
+ "classmap": [
+ "src/"
+ ]
+ },
+ "notification-url": "https://packagist.org/downloads/",
+ "license": [
+ "BSD-3-Clause"
+ ],
+ "authors": [
+ {
+ "name": "Sebastian Bergmann",
+ "email": "sebastian@phpunit.de"
+ }
+ ],
+ "description": "Allows reflection of object attributes, including inherited and non-public ones",
+ "homepage": "https://github.com/sebastianbergmann/object-reflector/",
+ "time": "2017-03-29T09:07:27+00:00"
+ },
+ {
+ "name": "sebastian/recursion-context",
+ "version": "3.0.0",
+ "source": {
+ "type": "git",
+ "url": "https://github.com/sebastianbergmann/recursion-context.git",
+ "reference": "5b0cd723502bac3b006cbf3dbf7a1e3fcefe4fa8"
+ },
+ "dist": {
+ "type": "zip",
+ "url": "https://api.github.com/repos/sebastianbergmann/recursion-context/zipball/5b0cd723502bac3b006cbf3dbf7a1e3fcefe4fa8",
+ "reference": "5b0cd723502bac3b006cbf3dbf7a1e3fcefe4fa8",
+ "shasum": ""
+ },
+ "require": {
+ "php": "^7.0"
+ },
+ "require-dev": {
+ "phpunit/phpunit": "^6.0"
+ },
+ "type": "library",
+ "extra": {
+ "branch-alias": {
+ "dev-master": "3.0.x-dev"
+ }
+ },
+ "autoload": {
+ "classmap": [
+ "src/"
+ ]
+ },
+ "notification-url": "https://packagist.org/downloads/",
+ "license": [
+ "BSD-3-Clause"
+ ],
+ "authors": [
+ {
+ "name": "Jeff Welch",
+ "email": "whatthejeff@gmail.com"
+ },
+ {
+ "name": "Sebastian Bergmann",
+ "email": "sebastian@phpunit.de"
+ },
+ {
+ "name": "Adam Harvey",
+ "email": "aharvey@php.net"
+ }
+ ],
+ "description": "Provides functionality to recursively process PHP variables",
+ "homepage": "http://www.github.com/sebastianbergmann/recursion-context",
+ "time": "2017-03-03T06:23:57+00:00"
+ },
+ {
+ "name": "sebastian/resource-operations",
+ "version": "1.0.0",
+ "source": {
+ "type": "git",
+ "url": "https://github.com/sebastianbergmann/resource-operations.git",
+ "reference": "ce990bb21759f94aeafd30209e8cfcdfa8bc3f52"
+ },
+ "dist": {
+ "type": "zip",
+ "url": "https://api.github.com/repos/sebastianbergmann/resource-operations/zipball/ce990bb21759f94aeafd30209e8cfcdfa8bc3f52",
+ "reference": "ce990bb21759f94aeafd30209e8cfcdfa8bc3f52",
+ "shasum": ""
+ },
+ "require": {
+ "php": ">=5.6.0"
+ },
+ "type": "library",
+ "extra": {
+ "branch-alias": {
+ "dev-master": "1.0.x-dev"
+ }
+ },
+ "autoload": {
+ "classmap": [
+ "src/"
+ ]
+ },
+ "notification-url": "https://packagist.org/downloads/",
+ "license": [
+ "BSD-3-Clause"
+ ],
+ "authors": [
+ {
+ "name": "Sebastian Bergmann",
+ "email": "sebastian@phpunit.de"
+ }
+ ],
+ "description": "Provides a list of PHP built-in functions that operate on resources",
+ "homepage": "https://www.github.com/sebastianbergmann/resource-operations",
+ "time": "2015-07-28T20:34:47+00:00"
+ },
+ {
+ "name": "sebastian/version",
+ "version": "2.0.1",
+ "source": {
+ "type": "git",
+ "url": "https://github.com/sebastianbergmann/version.git",
+ "reference": "99732be0ddb3361e16ad77b68ba41efc8e979019"
+ },
+ "dist": {
+ "type": "zip",
+ "url": "https://api.github.com/repos/sebastianbergmann/version/zipball/99732be0ddb3361e16ad77b68ba41efc8e979019",
+ "reference": "99732be0ddb3361e16ad77b68ba41efc8e979019",
+ "shasum": ""
+ },
+ "require": {
+ "php": ">=5.6"
+ },
+ "type": "library",
+ "extra": {
+ "branch-alias": {
+ "dev-master": "2.0.x-dev"
+ }
+ },
+ "autoload": {
+ "classmap": [
+ "src/"
+ ]
+ },
+ "notification-url": "https://packagist.org/downloads/",
+ "license": [
+ "BSD-3-Clause"
+ ],
+ "authors": [
+ {
+ "name": "Sebastian Bergmann",
+ "email": "sebastian@phpunit.de",
+ "role": "lead"
+ }
+ ],
+ "description": "Library that helps with managing the version number of Git-hosted PHP projects",
+ "homepage": "https://github.com/sebastianbergmann/version",
+ "time": "2016-10-03T07:35:21+00:00"
+ },
+ {
+ "name": "symfony/polyfill-ctype",
+ "version": "v1.18.1",
+ "source": {
+ "type": "git",
+ "url": "https://github.com/symfony/polyfill-ctype.git",
+ "reference": "1c302646f6efc070cd46856e600e5e0684d6b454"
+ },
+ "dist": {
+ "type": "zip",
+ "url": "https://api.github.com/repos/symfony/polyfill-ctype/zipball/1c302646f6efc070cd46856e600e5e0684d6b454",
+ "reference": "1c302646f6efc070cd46856e600e5e0684d6b454",
+ "shasum": ""
+ },
+ "require": {
+ "php": ">=5.3.3"
+ },
+ "suggest": {
+ "ext-ctype": "For best performance"
+ },
+ "type": "library",
+ "extra": {
+ "branch-alias": {
+ "dev-master": "1.18-dev"
+ },
+ "thanks": {
+ "name": "symfony/polyfill",
+ "url": "https://github.com/symfony/polyfill"
+ }
+ },
+ "autoload": {
+ "psr-4": {
+ "Symfony\\Polyfill\\Ctype\\": ""
+ },
+ "files": [
+ "bootstrap.php"
+ ]
+ },
+ "notification-url": "https://packagist.org/downloads/",
+ "license": [
+ "MIT"
+ ],
+ "authors": [
+ {
+ "name": "Gert de Pagter",
+ "email": "BackEndTea@gmail.com"
+ },
+ {
+ "name": "Symfony Community",
+ "homepage": "https://symfony.com/contributors"
+ }
+ ],
+ "description": "Symfony polyfill for ctype functions",
+ "homepage": "https://symfony.com",
+ "keywords": [
+ "compatibility",
+ "ctype",
+ "polyfill",
+ "portable"
+ ],
+ "funding": [
+ {
+ "url": "https://symfony.com/sponsor",
+ "type": "custom"
+ },
+ {
+ "url": "https://github.com/fabpot",
+ "type": "github"
+ },
+ {
+ "url": "https://tidelift.com/funding/github/packagist/symfony/symfony",
+ "type": "tidelift"
+ }
+ ],
+ "time": "2020-07-14T12:35:20+00:00"
+ },
+ {
+ "name": "theseer/tokenizer",
+ "version": "1.2.0",
+ "source": {
+ "type": "git",
+ "url": "https://github.com/theseer/tokenizer.git",
+ "reference": "75a63c33a8577608444246075ea0af0d052e452a"
+ },
+ "dist": {
+ "type": "zip",
+ "url": "https://api.github.com/repos/theseer/tokenizer/zipball/75a63c33a8577608444246075ea0af0d052e452a",
+ "reference": "75a63c33a8577608444246075ea0af0d052e452a",
+ "shasum": ""
+ },
+ "require": {
+ "ext-dom": "*",
+ "ext-tokenizer": "*",
+ "ext-xmlwriter": "*",
+ "php": "^7.2 || ^8.0"
+ },
+ "type": "library",
+ "autoload": {
+ "classmap": [
+ "src/"
+ ]
+ },
+ "notification-url": "https://packagist.org/downloads/",
+ "license": [
+ "BSD-3-Clause"
+ ],
+ "authors": [
+ {
+ "name": "Arne Blankerts",
+ "email": "arne@blankerts.de",
+ "role": "Developer"
+ }
+ ],
+ "description": "A small library for converting tokenized PHP source code into XML and potentially other formats",
+ "funding": [
+ {
+ "url": "https://github.com/theseer",
+ "type": "github"
+ }
+ ],
+ "time": "2020-07-12T23:59:07+00:00"
+ },
+ {
+ "name": "webmozart/assert",
+ "version": "1.9.1",
+ "source": {
+ "type": "git",
+ "url": "https://github.com/webmozart/assert.git",
+ "reference": "bafc69caeb4d49c39fd0779086c03a3738cbb389"
+ },
+ "dist": {
+ "type": "zip",
+ "url": "https://api.github.com/repos/webmozart/assert/zipball/bafc69caeb4d49c39fd0779086c03a3738cbb389",
+ "reference": "bafc69caeb4d49c39fd0779086c03a3738cbb389",
+ "shasum": ""
+ },
+ "require": {
+ "php": "^5.3.3 || ^7.0 || ^8.0",
+ "symfony/polyfill-ctype": "^1.8"
+ },
+ "conflict": {
+ "phpstan/phpstan": "<0.12.20",
+ "vimeo/psalm": "<3.9.1"
+ },
+ "require-dev": {
+ "phpunit/phpunit": "^4.8.36 || ^7.5.13"
+ },
+ "type": "library",
+ "autoload": {
+ "psr-4": {
+ "Webmozart\\Assert\\": "src/"
+ }
+ },
+ "notification-url": "https://packagist.org/downloads/",
+ "license": [
+ "MIT"
+ ],
+ "authors": [
+ {
+ "name": "Bernhard Schussek",
+ "email": "bschussek@gmail.com"
+ }
+ ],
+ "description": "Assertions to validate method input/output with nice error messages.",
+ "keywords": [
+ "assert",
+ "check",
+ "validate"
+ ],
+ "time": "2020-07-08T17:02:28+00:00"
+ }
+ ],
+ "aliases": [],
+ "minimum-stability": "stable",
+ "stability-flags": [],
+ "prefer-stable": false,
+ "prefer-lowest": false,
+ "platform": {
+ "php": ">=5.4"
+ },
+ "platform-dev": [],
+ "plugin-api-version": "1.1.0"
+}
diff --git a/hdz/vendor/zbateson/mb-wrapper/src/MbWrapper.php b/hdz/vendor/zbateson/mb-wrapper/src/MbWrapper.php
new file mode 100644
index 0000000..f166d15
--- /dev/null
+++ b/hdz/vendor/zbateson/mb-wrapper/src/MbWrapper.php
@@ -0,0 +1,469 @@
+ 'CP850',
+ 'GB2312' => 'GB2312',
+ 'SJIS2004' => 'SJIS-2004',
+ // aliases
+ 'ANSIX341968' => 'ASCII',
+ 'ANSIX341986' => 'ASCII',
+ 'ARABIC' => 'ISO-8859-6',
+ 'ASMO708' => 'ISO-8859-6',
+ 'BIG5' => 'BIG-5',
+ 'BIG5TW' => 'BIG-5',
+ 'CHINESE' => 'GB2312',
+ 'CP367' => 'ASCII',
+ 'CP819' => 'ISO-8859-1',
+ 'CP1251' => 'WINDOWS-1251',
+ 'CP1252' => 'WINDOWS-1252',
+ 'CP1254' => 'WINDOWS-1254',
+ 'CP1255' => 'ISO-8859-8',
+ 'CSASCII' => 'ASCII',
+ 'CSBIG5' => 'BIG-5',
+ 'CSIBM866' => 'CP866',
+ 'CSISO2022JP' => 'ISO-2022-JP',
+ 'CSISO2022KR' => 'ISO-2022-KR',
+ 'CSISO58GB231280' => 'GB2312',
+ 'CSISOLATIN1' => 'ISO-8859-1',
+ 'CSISOLATIN2' => 'ISO-8859-2',
+ 'CSISOLATIN3' => 'ISO-8859-3',
+ 'CSISOLATIN4' => 'ISO-8859-4',
+ 'CSISOLATIN5' => 'ISO-8859-9',
+ 'CSISOLATIN6' => 'ISO-8859-10',
+ 'CSISOLATINARABIC' => 'ISO-8859-6',
+ 'CSISOLATINCYRILLIC' => 'ISO-8859-5',
+ 'CSISOLATINGREEK' => 'ISO-8859-7',
+ 'CSISOLATINHEBREW' => 'ISO-8859-8',
+ 'CSKOI8R' => 'KOI8-R',
+ 'CSPC850MULTILINGUAL' => 'CP850',
+ 'CSSHIFTJIS' => 'SJIS',
+ 'CYRILLIC' => 'ISO-8859-5',
+ 'ECMA114' => 'ISO-8859-6',
+ 'ECMA118' => 'ISO-8859-7',
+ 'ELOT928' => 'ISO-8859-7',
+ 'EUCCN' => 'GB2312',
+ 'EUCGB2312CN' => 'GB2312',
+ 'GB180302000' => 'GB18030',
+ 'GB23121980' => 'GB2312',
+ 'GB231280' => 'GB2312',
+ 'GBK' => 'CP936',
+ 'GREEK8' => 'ISO-8859-7',
+ 'GREEK' => 'ISO-8859-7',
+ 'HEBREW' => 'ISO-8859-8',
+ 'HZGB2312' => 'HZ',
+ 'HZGB' => 'HZ',
+ 'IBM367' => 'ASCII',
+ 'IBM819' => 'ISO-8859-1',
+ 'IBM850' => 'CP850',
+ 'IBM866' => 'CP866',
+ 'ISO2022JP2004' => 'ISO-2022-JP-2004',
+ 'ISO646IRV1991' => 'ASCII',
+ 'ISO646US' => 'ASCII',
+ 'ISO8859' => 'ISO-8859-1',
+ 'ISO8859101992' => 'ISO-8859-10',
+ 'ISO885911987' => 'ISO-8859-1',
+ 'ISO8859141998' => 'ISO-8859-14',
+ 'ISO8859162001' => 'ISO-8859-16',
+ 'ISO885921987' => 'ISO-8859-2',
+ 'ISO885931988' => 'ISO-8859-3',
+ 'ISO885941988' => 'ISO-8859-4',
+ 'ISO885951988' => 'ISO-8859-5',
+ 'ISO885961987' => 'ISO-8859-6',
+ 'ISO885971987' => 'ISO-8859-7',
+ 'ISO885981988' => 'ISO-8859-8',
+ 'ISO88598I' => 'ISO-8859-8',
+ 'ISO885991989' => 'ISO-8859-9',
+ 'ISOCELTIC' => 'ISO-8859-14',
+ 'ISOIR100' => 'ISO-8859-1',
+ 'ISOIR101' => 'ISO-8859-2',
+ 'ISOIR109' => 'ISO-8859-3',
+ 'ISOIR110' => 'ISO-8859-4',
+ 'ISOIR126' => 'ISO-8859-7',
+ 'ISOIR127' => 'ISO-8859-6',
+ 'ISOIR138' => 'ISO-8859-8',
+ 'ISOIR144' => 'ISO-8859-5',
+ 'ISOIR148' => 'ISO-8859-9',
+ 'ISOIR157' => 'ISO-8859-10',
+ 'ISOIR199' => 'ISO-8859-14',
+ 'ISOIR226' => 'ISO-8859-16',
+ 'ISOIR58' => 'GB2312',
+ 'ISOIR6' => 'ASCII',
+ 'KOI8R' => 'KOI8-R',
+ 'KOREAN' => 'EUC-KR',
+ 'KSC56011987' => 'EUC-KR',
+ 'KSC5601' => 'EUC-KR',
+ 'KSX1001' => 'EUC-KR',
+ 'L1' => 'ISO-8859-1',
+ 'L2' => 'ISO-8859-2',
+ 'L3' => 'ISO-8859-3',
+ 'L4' => 'ISO-8859-4',
+ 'L5' => 'ISO-8859-9',
+ 'L6' => 'ISO-8859-10',
+ 'L8' => 'ISO-8859-14',
+ 'L10' => 'ISO-8859-16',
+ 'LATIN' => 'ISO-8859-1',
+ 'LATIN1' => 'ISO-8859-1',
+ 'LATIN2' => 'ISO-8859-2',
+ 'LATIN3' => 'ISO-8859-3',
+ 'LATIN4' => 'ISO-8859-4',
+ 'LATIN5' => 'ISO-8859-9',
+ 'LATIN6' => 'ISO-8859-10',
+ 'LATIN8' => 'ISO-8859-14',
+ 'LATIN10' => 'ISO-8859-16',
+ 'MS932' => 'CP932',
+ 'ms936' => 'CP936',
+ 'MS950' => 'CP950',
+ 'MSKANJI' => 'CP932',
+ 'SHIFTJIS2004' => 'SJIS',
+ 'SHIFTJIS' => 'SJIS',
+ 'UJIS' => 'EUC-JP',
+ 'US' => 'ASCII',
+ 'USASCII' => 'ASCII',
+ 'WE8MSWIN1252' => 'WINDOWS-1252',
+ 'WINDOWS1251' => 'WINDOWS-1251',
+ 'WINDOWS1252' => 'WINDOWS-1252',
+ 'WINDOWS1254' => 'WINDOWS-1254',
+ 'WINDOWS1255' => 'ISO-8859-8',
+ '0' => 'WINDOWS-1252',
+ '128' => 'SJIS',
+ '129' => 'EUC-KR',
+ '134' => 'GB2312',
+ '136' => 'BIG-5',
+ '161' => 'WINDOWS-1253',
+ '162' => 'WINDOWS-1254',
+ '177' => 'WINDOWS-1255',
+ '178' => 'WINDOWS-1256',
+ '186' => 'WINDOWS-1257',
+ '204' => 'WINDOWS-1251',
+ '222' => 'WINDOWS-874',
+ '238' => 'WINDOWS-1250',
+ '646' => 'ASCII',
+ '850' => 'CP850',
+ '866' => 'CP866',
+ '932' => 'CP932',
+ '936' => 'CP936',
+ '950' => 'CP950',
+ '1251' => 'WINDOWS-1251',
+ '1252' => 'WINDOWS-1252',
+ '1254' => 'WINDOWS-1254',
+ '1255' => 'ISO-8859-8',
+ '8859' => 'ISO-8859-1',
+ ];
+
+ /**
+ * @var array aliased charsets supported by iconv.
+ */
+ public static $iconvAliases = [
+ // iconv aliases -- a lot of these may already be supported
+ 'CP154' => 'PT154',
+ 'CPGR' => 'CP869',
+ 'CPIS' => 'CP861',
+ 'CSHPROMAN8' => 'ROMAN8',
+ 'CSIBM037' => 'CP037',
+ 'CSIBM1026' => 'CP1026',
+ 'CSIBM424' => 'CP424',
+ 'CSIBM500' => 'CP500',
+ 'CSIBM860' => 'CP860',
+ 'CSIBM861' => 'CP861',
+ 'CSIBM863' => 'CP863',
+ 'CSIBM864' => 'CP864',
+ 'CSIBM865' => 'CP865',
+ 'CSIBM869' => 'CP869',
+ 'CSPC775BALTIC' => 'CP775',
+ 'CSPC862LATINHEBREW' => 'CP862',
+ 'CSPC8CODEPAGE437' => 'CP437',
+ 'CSPTCP154' => 'PT154',
+ 'CYRILLICASIAN' => 'PT154',
+ 'EBCDICCPBE' => 'CP500',
+ 'EBCDICCPCA' => 'CP037',
+ 'EBCDICCPCH' => 'CP500',
+ 'EBCDICCPHE' => 'CP424',
+ 'EBCDICCPNL' => 'CP037',
+ 'EBCDICCPUS' => 'CP037',
+ 'EBCDICCPWT' => 'CP037',
+ 'HKSCS' => 'BIG5HKSCS',
+ 'HPROMAN8' => 'ROMAN8',
+ 'IBM037' => 'CP037',
+ 'IBM039' => 'CP037',
+ 'IBM424' => 'CP424',
+ 'IBM437' => 'CP437',
+ 'IBM500' => 'CP500',
+ 'IBM775' => 'CP775',
+ 'IBM860' => 'CP860',
+ 'IBM861' => 'CP861',
+ 'IBM862' => 'CP862',
+ 'IBM863' => 'CP863',
+ 'IBM864' => 'CP864',
+ 'IBM865' => 'CP865',
+ 'IBM869' => 'CP869',
+ 'IBM1026' => 'CP1026',
+ 'IBM1140' => 'CP1140',
+ 'ISO2022JP2' => 'ISO2022JP2',
+ 'ISO8859112001' => 'ISO885911',
+ 'ISO885911' => 'ISO885911',
+ 'ISOIR166' => 'TIS620',
+ 'JOHAB' => 'CP1361',
+ 'MACCYRILLIC' => 'MACCYRILLIC',
+ 'MS1361' => 'CP1361',
+ 'MS949' => 'CP949',
+ 'PTCP154' => 'PT154',
+ 'R8' => 'ROMAN8',
+ 'ROMAN8' => 'ROMAN8',
+ 'THAI' => 'ISO885911',
+ 'TIS6200' => 'TIS620',
+ 'TIS62025290' => 'TIS620',
+ 'TIS62025291' => 'TIS620',
+ 'TIS620' => 'TIS620',
+ 'UHC' => 'CP949',
+ 'WINDOWS1250' => 'CP1250',
+ 'WINDOWS1253' => 'CP1253',
+ 'WINDOWS1256' => 'CP1256',
+ 'WINDOWS1257' => 'CP1257',
+ 'WINDOWS1258' => 'CP1258',
+ '037' => 'CP037',
+ '424' => 'CP424',
+ '437' => 'CP437',
+ '500' => 'CP500',
+ '775' => 'CP775',
+ '860' => 'CP860',
+ '861' => 'CP861',
+ '862' => 'CP862',
+ '863' => 'CP863',
+ '864' => 'CP864',
+ '865' => 'CP865',
+ '869' => 'CP869',
+ '949' => 'CP949',
+ '1026' => 'CP1026',
+ '1140' => 'CP1140',
+ '1250' => 'CP1250',
+ '1253' => 'CP1253',
+ '1256' => 'CP1256',
+ '1257' => 'CP1257',
+ '1258' => 'CP1258',
+ ];
+
+ /**
+ * @var string[] An array of encodings supported by the mb_* extension, as
+ * returned by mb_list_encodings(), with the key set to the charset's
+ * name afte
+ */
+ private static $mbListedEncodings;
+
+ /**
+ * @var string[] cached lookups for quicker retrieval
+ */
+ protected $mappedMbCharsets = [
+ 'UTF8' => 'UTF-8',
+ 'USASCII' => 'US-ASCII',
+ 'ISO88591' => 'ISO-8859-1',
+ ];
+
+ /**
+ * Initializes the static mb_* encoding array.
+ */
+ public function __construct()
+ {
+ if (self::$mbListedEncodings === null) {
+ $cs = mb_list_encodings();
+ $keys = $this->getNormalizedCharset($cs);
+ self::$mbListedEncodings = array_combine($keys, $cs);
+ }
+ }
+
+ /**
+ * The passed charset is uppercased, and stripped of non-alphanumeric
+ * characters before being returned.
+ *
+ * @param string|string[] $charset
+ * @return string|string[]
+ */
+ private function getNormalizedCharset($charset)
+ {
+ $upper = null;
+ if (is_array($charset)) {
+ $upper = array_map('strtoupper', $charset);
+ } else {
+ $upper = strtoupper($charset);
+ }
+ return preg_replace('/[^A-Z0-9]+/', '', $upper);
+ }
+
+ /**
+ * Converts the passed string's charset from the passed $fromCharset to the
+ * passed $toCharset
+ *
+ * The function attempts to use mb_convert_encoding if possible, and falls
+ * back to iconv if not. If the source or destination character sets aren't
+ * supported, a blank string is returned.
+ *
+ * @param string $str
+ * @return string
+ */
+ public function convert($str, $fromCharset, $toCharset)
+ {
+ // there may be some mb-supported encodings not supported by iconv (on my libiconv for instance
+ // HZ isn't supported), and so it may happen that failing an mb_convert_encoding, an iconv
+ // may also fail even though both support an encoding separately.
+ // For cases like that, a two-way encoding is done with UTF-8 as an intermediary.
+
+ $from = $this->getMbCharset($fromCharset);
+ $to = $this->getMbCharset($toCharset);
+
+ if ($str !== '') {
+ if ($from !== false && $to === false) {
+ $str = mb_convert_encoding($str, 'UTF-8', $from);
+ return iconv('UTF-8', $this->getIconvAlias($toCharset) . '//TRANSLIT//IGNORE', $str);
+ } elseif ($from === false && $to !== false) {
+ $str = iconv($this->getIconvAlias($fromCharset), 'UTF-8//TRANSLIT//IGNORE', $str);
+ return mb_convert_encoding($str, $to, 'UTF-8');
+ } elseif ($from !== false && $to !== false) {
+ return mb_convert_encoding($str, $to, $from);
+ }
+ return iconv(
+ $this->getIconvAlias($fromCharset),
+ $this->getIconvAlias($toCharset) . '//TRANSLIT//IGNORE',
+ $str
+ );
+ }
+ return $str;
+ }
+
+ /**
+ * Returns true if the passed string is valid in the $charset encoding.
+ *
+ * Either uses mb_check_encoding, or iconv if it's not a supported mb
+ * encoding.
+ *
+ * @param type $str
+ * @param type $charset
+ */
+ public function checkEncoding($str, $charset)
+ {
+ $mb = $this->getMbCharset($charset);
+ if ($mb !== false) {
+ return mb_check_encoding($str, $mb);
+ }
+ $ic = $this->getIconvAlias($charset);
+ return (@iconv($ic, $ic, $str) !== false);
+ }
+
+ /**
+ * Uses either mb_strlen or iconv_strlen to return the number of characters
+ * in the passed $str for the given $charset
+ *
+ * @param string $str
+ * @param string $charset
+ * @return int
+ */
+ public function getLength($str, $charset)
+ {
+ $mb = $this->getMbCharset($charset);
+ if ($mb !== false) {
+ return mb_strlen($str, $mb);
+ }
+ return iconv_strlen($str, $this->getIconvAlias($charset));
+ }
+
+ /**
+ * Uses either mb_substr or iconv_substr to create and return a substring of
+ * the passed $str.
+ *
+ * @param string $str
+ * @param string $charset
+ * @param int $start
+ * @param int $length
+ * @return string
+ */
+ public function getSubstr($str, $charset, $start, $length = null)
+ {
+ $mb = $this->getMbCharset($charset);
+ if ($mb !== false) {
+ return mb_substr($str, $start, $length, $mb);
+ }
+ $ic = $this->getIconvAlias($charset);
+ if ($ic === 'CP1258') {
+ // iconv_substr fails with CP1258 for some reason, and returns only
+ // a subset of characters (e.g. the first 5, instead of $length)
+ $str = $this->convert($str, $ic, 'UTF-8');
+ return $this->convert($this->getSubstr($str, 'UTF-8', $start, $length), 'UTF-8', $ic);
+ }
+ if ($length === null) {
+ $length = iconv_strlen($str, $ic);
+ }
+ return iconv_substr($str, $start, $length, $ic);
+ }
+
+
+
+ /**
+ * Looks up a charset from mb_list_encodings and identified aliases,
+ * checking if the lookup has been cached already first.
+ *
+ * If the encoding is not listed, the method will return false.
+ *
+ * On success, the method will return the charset name as accepted by mb_*.
+ *
+ * @param string $cs
+ * @param bool $mbSupported
+ * @return string|bool
+ */
+ private function getMbCharset($cs)
+ {
+ $normalized = $this->getNormalizedCharset($cs);
+ if (array_key_exists($normalized, self::$mbListedEncodings)) {
+ return self::$mbListedEncodings[$normalized];
+ } elseif (array_key_exists($normalized, self::$mbAliases)) {
+ return self::$mbAliases[$normalized];
+ }
+ return false;
+ }
+
+ /**
+ * Looks up the passed charset in self::$iconvAliases, returning the mapped
+ * charset if applicable. Otherwise returns charset.
+ *
+ * @param string $cs
+ * @return string the mapped charset (if mapped) or $cs otherwise
+ */
+ private function getIconvAlias($cs)
+ {
+ $normalized = $this->getNormalizedCharset($cs);
+ if (array_key_exists($normalized, self::$iconvAliases)) {
+ return static::$iconvAliases[$normalized];
+ }
+ return $cs;
+ }
+}
diff --git a/hdz/vendor/zbateson/mb-wrapper/tests/MbWrapper/MbWrapperTest.php b/hdz/vendor/zbateson/mb-wrapper/tests/MbWrapper/MbWrapperTest.php
new file mode 100644
index 0000000..55c27bf
--- /dev/null
+++ b/hdz/vendor/zbateson/mb-wrapper/tests/MbWrapper/MbWrapperTest.php
@@ -0,0 +1,177 @@
+convert('This is my string', 'UTF-8', $first);
+ foreach ($arr as $dest) {
+ $this->assertEquals(
+ $test,
+ $converter->convert($converter->convert($test, $first, $dest), $dest, $first)
+ );
+ }
+ }
+
+ public function testIconvCharsetConversion()
+ {
+ $arr = array_unique(MbWrapper::$iconvAliases);
+ $converter = new MbWrapper();
+ $first = reset($arr);
+ $test = $converter->convert('This is my string', 'UTF-8', $first);
+ foreach ($arr as $dest) {
+ $this->assertEquals($test, $converter->convert($converter->convert($test, $first, $dest), $dest, $first));
+ }
+ }
+
+ public function testMbConversionWithEmptyString()
+ {
+ $converter = new MbWrapper();
+ $cs = reset(MbWrapper::$mbAliases);
+ $this->assertEmpty($converter->convert('', 'UTF-8', $cs));
+ }
+
+ public function testIconvConversionWithEmptyString()
+ {
+ $converter = new MbWrapper();
+ $cs = reset(MbWrapper::$iconvAliases);
+ $this->assertEmpty($converter->convert('', 'UTF-8', $cs));
+ }
+
+ public function testMbIconvMixedCharsetConversion()
+ {
+ $mbArr = array_unique(MbWrapper::$mbAliases);
+ $iconvArr = array_unique(MbWrapper::$iconvAliases);
+ $converter = new MbWrapper();
+
+ $mb = reset($mbArr);
+ $iconv = reset($iconvArr);
+
+ $testMb = $converter->convert('This is my string', 'UTF-8', $mb);
+ $testIconv = $converter->convert('This is my string', 'UTF-8', $iconv);
+
+ foreach ($iconvArr as $dest) {
+ $this->assertEquals($testMb, $converter->convert($converter->convert($testMb, $mb, $dest), $dest, $mb));
+ }
+ foreach ($mbArr as $dest) {
+ $this->assertEquals($testIconv, $converter->convert($converter->convert($testIconv, $iconv, $dest), $dest, $iconv));
+ }
+ }
+
+ public function testSetCharsetConversions()
+ {
+ $arr = [
+ 'ISO-8859-8-I',
+ 'WINDOWS-1254',
+ 'CSPC-850-MULTILINGUAL',
+ 'GB18030_2000',
+ 'ISO_IR_157',
+ 'CS-ISO-LATIN-4',
+ 'ISO_IR_100',
+ 'WINDOWS-&#Ӧ',
+ 'UTF-#@*(@8',
+ 'ISO-&@(#IR166'
+ ];
+ $test = 'This is my string';
+ $converter = new MbWrapper();
+ foreach ($arr as $dest) {
+ $this->assertEquals($test, $converter->convert($converter->convert($test, 'UTF-8', $dest), $dest, 'UTF-8'), "Testing with $dest");
+ }
+ }
+
+ public function testMbStrlen()
+ {
+ $arr = array_unique(MbWrapper::$mbAliases);
+ $converter = new MbWrapper();
+ $str = 'هلا والله بالغالي';
+ $len = mb_strlen($str, 'UTF-8');
+ $first = reset($arr);
+ $test = $converter->convert($str, 'UTF-8', $first);
+ foreach ($arr as $dest) {
+ $this->assertEquals($len, $converter->getLength($converter->convert($test, $first, $dest), $dest));
+ }
+ }
+
+ public function testIconvStrlen()
+ {
+ $arr = array_unique(MbWrapper::$iconvAliases);
+ $converter = new MbWrapper();
+ $str = 'هلا والله بالغالي';
+ $len = mb_strlen($str, 'UTF-8');
+ $first = reset($arr);
+ $test = $converter->convert($str, 'UTF-8', $first);
+ foreach ($arr as $dest) {
+ $this->assertEquals($len, $converter->getLength($converter->convert($test, $first, $dest), $dest));
+ }
+ }
+
+ public function testMbSubstr()
+ {
+ $arr = array_unique(MbWrapper::$mbAliases);
+ $converter = new MbWrapper();
+ $str = 'Needs to be simple';
+ $len = mb_strlen($str, 'UTF-8');
+ $first = reset($arr);
+ $test = $converter->convert($str, 'UTF-8', $first);
+ foreach ($arr as $dest) {
+ $testConv = $converter->convert($test, $first, $dest);
+ for ($i = 0; $i < $len; ++$i) {
+ for ($j = $i + 1; $j <= $len; ++$j) {
+ $this->assertEquals(
+ mb_substr($str, $i, $j),
+ $converter->convert($converter->getSubstr($testConv, $dest, $i, $j), $dest, 'UTF-8'),
+ "Failed on $i iteration $j with " . $converter->convert($testConv, $dest, 'UTF-8')
+ );
+ }
+ $this->assertEquals(
+ mb_substr($str, $i),
+ $converter->convert($converter->getSubstr($testConv, $dest, $i), $dest, 'UTF-8')
+ );
+ }
+
+ }
+ }
+
+ public function testIconvSubstr()
+ {
+ $arr = array_unique(MbWrapper::$iconvAliases);
+ $converter = new MbWrapper();
+ $str = 'Needs to be simple';
+ $len = mb_strlen($str, 'UTF-8');
+ $first = reset($arr);
+ $test = $converter->convert($str, 'UTF-8', $first);
+
+ // seems to fail only on CP1258, returns incorrect number of characters with iconv_substr
+ // $arr = array_diff($arr);
+
+ foreach ($arr as $dest) {
+ $testConv = $converter->convert($test, $first, $dest);
+ for ($i = 0; $i < $len; ++$i) {
+ for ($j = $i + 1; $j <= $len; ++$j) {
+ $this->assertEquals(
+ mb_substr($str, $i, $j),
+ $converter->convert($converter->getSubstr($testConv, $dest, $i, $j), $dest, 'UTF-8'),
+ "Failed on $i iteration $j with " . $converter->convert($testConv, $dest, 'UTF-8')
+ );
+ }
+ $this->assertEquals(
+ mb_substr($str, $i),
+ $converter->convert($converter->getSubstr($testConv, $dest, $i), $dest, 'UTF-8')
+ );
+ }
+
+ }
+ }
+}
diff --git a/hdz/vendor/zbateson/mb-wrapper/tests/bootstrap.php b/hdz/vendor/zbateson/mb-wrapper/tests/bootstrap.php
new file mode 100644
index 0000000..b6703fd
--- /dev/null
+++ b/hdz/vendor/zbateson/mb-wrapper/tests/bootstrap.php
@@ -0,0 +1,2 @@
+
+
+
+
+ MbWrapper
+
+
+
diff --git a/hdz/vendor/zbateson/stream-decorators/.github/FUNDING.yml b/hdz/vendor/zbateson/stream-decorators/.github/FUNDING.yml
new file mode 100644
index 0000000..f137cf6
--- /dev/null
+++ b/hdz/vendor/zbateson/stream-decorators/.github/FUNDING.yml
@@ -0,0 +1,3 @@
+# These are supported funding model platforms
+
+github: zbateson
diff --git a/hdz/vendor/zbateson/stream-decorators/LICENSE b/hdz/vendor/zbateson/stream-decorators/LICENSE
new file mode 100644
index 0000000..2ee4a46
--- /dev/null
+++ b/hdz/vendor/zbateson/stream-decorators/LICENSE
@@ -0,0 +1,25 @@
+BSD 2-Clause License
+
+Copyright (c) 2017, Zaahid Bateson
+All rights reserved.
+
+Redistribution and use in source and binary forms, with or without
+modification, are permitted provided that the following conditions are met:
+
+* Redistributions of source code must retain the above copyright notice, this
+ list of conditions and the following disclaimer.
+
+* 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.
+
+THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS"
+AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
+IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
+DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE LIABLE
+FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
+DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR
+SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER
+CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY,
+OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
+OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
diff --git a/hdz/vendor/zbateson/stream-decorators/README.md b/hdz/vendor/zbateson/stream-decorators/README.md
new file mode 100644
index 0000000..b02837f
--- /dev/null
+++ b/hdz/vendor/zbateson/stream-decorators/README.md
@@ -0,0 +1,67 @@
+# zbateson/stream-decorators
+
+Psr7 stream decorators for character set conversion and common mail format content encodings.
+
+[](https://travis-ci.org/zbateson/stream-decorators)
+[](https://scrutinizer-ci.com/g/zbateson/stream-decorators/?branch=master)
+[](https://scrutinizer-ci.com/g/zbateson/stream-decorators/?branch=master)
+[](https://packagist.org/packages/zbateson/stream-decorators)
+[](https://packagist.org/packages/zbateson/stream-decorators)
+
+The goals of this project are to be:
+
+* Well written
+* Standards-compliant but forgiving
+* Tested where possible
+
+To include it for use in your project, please install via composer:
+
+```
+composer require zbateson/stream-decorators
+```
+
+## Requirements
+
+StreamDecorators requires PHP 5.4 or newer. Tested on PHP 5.4, 5.5, 5.6, 7, 7.1, 7.2 and 7.3 on travis.
+
+Please note: hhvm support has been dropped as it no longer supports 'php' as of version 4. Previous versions of hhvm may still work, but are no longer supported.
+
+
+## Usage
+
+```php
+$stream = GuzzleHttp\Psr7\stream_for($handle);
+$b64Stream = new ZBateson\StreamDecorators\Base64Stream($stream);
+$charsetStream = new ZBateson\StreamDecorators\CharsetStream($b64Stream, 'UTF-32', 'UTF-8');
+
+while (($line = GuzzleHttp\Psr7\readline()) !== false) {
+ echo $line, "\r\n";
+}
+
+```
+
+Note that CharsetStream, depending on the target encoding, may return multiple bytes when a single 'char' is read. If using php's 'fread', this will result in a warning:
+
+'read x bytes more data than requested (xxxx read, xxxx max) - excess data will be lost
+
+This is because the parameter to 'fread' is bytes, and so when CharsetStream returns, say, 4 bytes representing a single UTF-32 character, fread will truncate to the first byte when requesting '1' byte. It is recommended to **not** convert to a stream handle (with StreamWrapper) for this reason when using CharsetStream.
+
+The library consists of the following Psr\Http\Message\StreamInterface implementations:
+* ZBateson\StreamDecorators\QuotedPrintableStream - decodes on read and encodes on write to quoted-printable
+* ZBateson\StreamDecorators\Base64Stream - decodes on read and encodes on write to base64
+* ZBateson\StreamDecorators\UUStream - decodes on read, encodes on write to uu-encoded
+* ZBateson\StreamDecorators\CharsetStream - encodes from $streamCharset to $stringCharset on read, and vice-versa on write
+* ZBateson\StreamDecorators\NonClosingStream - overrides close() and detach(), and simply unsets the attached stream without closing it
+* ZBateson\StreamDecorators\ChunkSplitStream - splits written characters into lines of $lineLength long (stream implementation of php's chunk_split)
+* ZBateson\StreamDecorators\PregReplaceFilterStream - calls preg_replace on with passed arguments on every read() call
+* ZBateson\StreamDecorators\SeekingLimitStream - similar to GuzzleHttp's LimitStream, but maintains an internal current read position, seeking to it when read() is called, and seeking back to the wrapped stream's position after reading
+
+QuotedPrintableStream, Base64Stream and UUStream's constructors take a single argument of a StreamInterface.
+CharsetStreams's constructor also takes $streamCharset and $stringCharset as arguments respectively, ChunkSplitStream
+optionally takes a $lineLength argument (defaults to 76) and a $lineEnding argument (defaults to CRLF).
+PregReplaceFilterStream takes a $pattern argument and a $replacement argument. SeekingLimitStream takes optional
+$limit and $offset parameters, similar to GuzzleHttp's LimitStream.
+
+## License
+
+BSD licensed - please see [license agreement](https://github.com/zbateson/stream-decorators/blob/master/LICENSE).
diff --git a/hdz/vendor/zbateson/stream-decorators/composer.json b/hdz/vendor/zbateson/stream-decorators/composer.json
new file mode 100644
index 0000000..51f43f8
--- /dev/null
+++ b/hdz/vendor/zbateson/stream-decorators/composer.json
@@ -0,0 +1,29 @@
+{
+ "name": "zbateson/stream-decorators",
+ "description": "PHP psr7 stream decorators for mime message part streams",
+ "keywords": ["psr7", "stream", "decorators", "mail", "mime", "base64", "quoted-printable", "uuencode", "charset"],
+ "license": "BSD-2-Clause",
+ "authors": [
+ {
+ "name": "Zaahid Bateson"
+ }
+ ],
+ "require": {
+ "php": ">=5.4",
+ "guzzlehttp/psr7": "^1.0.0",
+ "zbateson/mb-wrapper": "^1.0.0"
+ },
+ "require-dev": {
+ "phpunit/phpunit": "^4.8 || ^5.7 || ^6.5 || ^7.5"
+ },
+ "autoload": {
+ "psr-4": {
+ "ZBateson\\StreamDecorators\\": "src/"
+ }
+ },
+ "autoload-dev": {
+ "psr-4": {
+ "ZBateson\\StreamDecorators\\": "tests/StreamDecorators"
+ }
+ }
+}
diff --git a/hdz/vendor/zbateson/stream-decorators/composer.lock b/hdz/vendor/zbateson/stream-decorators/composer.lock
new file mode 100644
index 0000000..3c57e54
--- /dev/null
+++ b/hdz/vendor/zbateson/stream-decorators/composer.lock
@@ -0,0 +1,1827 @@
+{
+ "_readme": [
+ "This file locks the dependencies of your project to a known state",
+ "Read more about it at https://getcomposer.org/doc/01-basic-usage.md#composer-lock-the-lock-file",
+ "This file is @generated automatically"
+ ],
+ "content-hash": "f53fb946f4951af46450c2ebb3e0cec0",
+ "packages": [
+ {
+ "name": "guzzlehttp/psr7",
+ "version": "1.6.1",
+ "source": {
+ "type": "git",
+ "url": "https://github.com/guzzle/psr7.git",
+ "reference": "239400de7a173fe9901b9ac7c06497751f00727a"
+ },
+ "dist": {
+ "type": "zip",
+ "url": "https://api.github.com/repos/guzzle/psr7/zipball/239400de7a173fe9901b9ac7c06497751f00727a",
+ "reference": "239400de7a173fe9901b9ac7c06497751f00727a",
+ "shasum": ""
+ },
+ "require": {
+ "php": ">=5.4.0",
+ "psr/http-message": "~1.0",
+ "ralouphie/getallheaders": "^2.0.5 || ^3.0.0"
+ },
+ "provide": {
+ "psr/http-message-implementation": "1.0"
+ },
+ "require-dev": {
+ "ext-zlib": "*",
+ "phpunit/phpunit": "~4.8.36 || ^5.7.27 || ^6.5.8"
+ },
+ "suggest": {
+ "zendframework/zend-httphandlerrunner": "Emit PSR-7 responses"
+ },
+ "type": "library",
+ "extra": {
+ "branch-alias": {
+ "dev-master": "1.6-dev"
+ }
+ },
+ "autoload": {
+ "psr-4": {
+ "GuzzleHttp\\Psr7\\": "src/"
+ },
+ "files": [
+ "src/functions_include.php"
+ ]
+ },
+ "notification-url": "https://packagist.org/downloads/",
+ "license": [
+ "MIT"
+ ],
+ "authors": [
+ {
+ "name": "Michael Dowling",
+ "email": "mtdowling@gmail.com",
+ "homepage": "https://github.com/mtdowling"
+ },
+ {
+ "name": "Tobias Schultze",
+ "homepage": "https://github.com/Tobion"
+ }
+ ],
+ "description": "PSR-7 message implementation that also provides common utility methods",
+ "keywords": [
+ "http",
+ "message",
+ "psr-7",
+ "request",
+ "response",
+ "stream",
+ "uri",
+ "url"
+ ],
+ "time": "2019-07-01T23:21:34+00:00"
+ },
+ {
+ "name": "psr/http-message",
+ "version": "1.0.1",
+ "source": {
+ "type": "git",
+ "url": "https://github.com/php-fig/http-message.git",
+ "reference": "f6561bf28d520154e4b0ec72be95418abe6d9363"
+ },
+ "dist": {
+ "type": "zip",
+ "url": "https://api.github.com/repos/php-fig/http-message/zipball/f6561bf28d520154e4b0ec72be95418abe6d9363",
+ "reference": "f6561bf28d520154e4b0ec72be95418abe6d9363",
+ "shasum": ""
+ },
+ "require": {
+ "php": ">=5.3.0"
+ },
+ "type": "library",
+ "extra": {
+ "branch-alias": {
+ "dev-master": "1.0.x-dev"
+ }
+ },
+ "autoload": {
+ "psr-4": {
+ "Psr\\Http\\Message\\": "src/"
+ }
+ },
+ "notification-url": "https://packagist.org/downloads/",
+ "license": [
+ "MIT"
+ ],
+ "authors": [
+ {
+ "name": "PHP-FIG",
+ "homepage": "http://www.php-fig.org/"
+ }
+ ],
+ "description": "Common interface for HTTP messages",
+ "homepage": "https://github.com/php-fig/http-message",
+ "keywords": [
+ "http",
+ "http-message",
+ "psr",
+ "psr-7",
+ "request",
+ "response"
+ ],
+ "time": "2016-08-06T14:39:51+00:00"
+ },
+ {
+ "name": "ralouphie/getallheaders",
+ "version": "3.0.3",
+ "source": {
+ "type": "git",
+ "url": "https://github.com/ralouphie/getallheaders.git",
+ "reference": "120b605dfeb996808c31b6477290a714d356e822"
+ },
+ "dist": {
+ "type": "zip",
+ "url": "https://api.github.com/repos/ralouphie/getallheaders/zipball/120b605dfeb996808c31b6477290a714d356e822",
+ "reference": "120b605dfeb996808c31b6477290a714d356e822",
+ "shasum": ""
+ },
+ "require": {
+ "php": ">=5.6"
+ },
+ "require-dev": {
+ "php-coveralls/php-coveralls": "^2.1",
+ "phpunit/phpunit": "^5 || ^6.5"
+ },
+ "type": "library",
+ "autoload": {
+ "files": [
+ "src/getallheaders.php"
+ ]
+ },
+ "notification-url": "https://packagist.org/downloads/",
+ "license": [
+ "MIT"
+ ],
+ "authors": [
+ {
+ "name": "Ralph Khattar",
+ "email": "ralph.khattar@gmail.com"
+ }
+ ],
+ "description": "A polyfill for getallheaders.",
+ "time": "2019-03-08T08:55:37+00:00"
+ },
+ {
+ "name": "symfony/polyfill-iconv",
+ "version": "v1.13.1",
+ "source": {
+ "type": "git",
+ "url": "https://github.com/symfony/polyfill-iconv.git",
+ "reference": "a019efccc03f1a335af6b4f20c30f5ea8060be36"
+ },
+ "dist": {
+ "type": "zip",
+ "url": "https://api.github.com/repos/symfony/polyfill-iconv/zipball/a019efccc03f1a335af6b4f20c30f5ea8060be36",
+ "reference": "a019efccc03f1a335af6b4f20c30f5ea8060be36",
+ "shasum": ""
+ },
+ "require": {
+ "php": ">=5.3.3"
+ },
+ "suggest": {
+ "ext-iconv": "For best performance"
+ },
+ "type": "library",
+ "extra": {
+ "branch-alias": {
+ "dev-master": "1.13-dev"
+ }
+ },
+ "autoload": {
+ "psr-4": {
+ "Symfony\\Polyfill\\Iconv\\": ""
+ },
+ "files": [
+ "bootstrap.php"
+ ]
+ },
+ "notification-url": "https://packagist.org/downloads/",
+ "license": [
+ "MIT"
+ ],
+ "authors": [
+ {
+ "name": "Nicolas Grekas",
+ "email": "p@tchwork.com"
+ },
+ {
+ "name": "Symfony Community",
+ "homepage": "https://symfony.com/contributors"
+ }
+ ],
+ "description": "Symfony polyfill for the Iconv extension",
+ "homepage": "https://symfony.com",
+ "keywords": [
+ "compatibility",
+ "iconv",
+ "polyfill",
+ "portable",
+ "shim"
+ ],
+ "time": "2019-11-27T13:56:44+00:00"
+ },
+ {
+ "name": "symfony/polyfill-mbstring",
+ "version": "v1.13.1",
+ "source": {
+ "type": "git",
+ "url": "https://github.com/symfony/polyfill-mbstring.git",
+ "reference": "7b4aab9743c30be783b73de055d24a39cf4b954f"
+ },
+ "dist": {
+ "type": "zip",
+ "url": "https://api.github.com/repos/symfony/polyfill-mbstring/zipball/7b4aab9743c30be783b73de055d24a39cf4b954f",
+ "reference": "7b4aab9743c30be783b73de055d24a39cf4b954f",
+ "shasum": ""
+ },
+ "require": {
+ "php": ">=5.3.3"
+ },
+ "suggest": {
+ "ext-mbstring": "For best performance"
+ },
+ "type": "library",
+ "extra": {
+ "branch-alias": {
+ "dev-master": "1.13-dev"
+ }
+ },
+ "autoload": {
+ "psr-4": {
+ "Symfony\\Polyfill\\Mbstring\\": ""
+ },
+ "files": [
+ "bootstrap.php"
+ ]
+ },
+ "notification-url": "https://packagist.org/downloads/",
+ "license": [
+ "MIT"
+ ],
+ "authors": [
+ {
+ "name": "Nicolas Grekas",
+ "email": "p@tchwork.com"
+ },
+ {
+ "name": "Symfony Community",
+ "homepage": "https://symfony.com/contributors"
+ }
+ ],
+ "description": "Symfony polyfill for the Mbstring extension",
+ "homepage": "https://symfony.com",
+ "keywords": [
+ "compatibility",
+ "mbstring",
+ "polyfill",
+ "portable",
+ "shim"
+ ],
+ "time": "2019-11-27T14:18:11+00:00"
+ },
+ {
+ "name": "zbateson/mb-wrapper",
+ "version": "1.0.0",
+ "source": {
+ "type": "git",
+ "url": "https://github.com/zbateson/mb-wrapper.git",
+ "reference": "723f25a1ab0e4e662efa8d89f38da751c799134a"
+ },
+ "dist": {
+ "type": "zip",
+ "url": "https://api.github.com/repos/zbateson/mb-wrapper/zipball/723f25a1ab0e4e662efa8d89f38da751c799134a",
+ "reference": "723f25a1ab0e4e662efa8d89f38da751c799134a",
+ "shasum": ""
+ },
+ "require": {
+ "php": ">=5.4",
+ "symfony/polyfill-iconv": "^1.9",
+ "symfony/polyfill-mbstring": "^1.9"
+ },
+ "require-dev": {
+ "phpunit/phpunit": "^4.8 || ^5.7 || ^6.5"
+ },
+ "suggest": {
+ "ext-iconv": "For best support/performance",
+ "ext-mbstring": "For best support/performance"
+ },
+ "type": "library",
+ "autoload": {
+ "psr-4": {
+ "ZBateson\\MbWrapper\\": "src/"
+ }
+ },
+ "notification-url": "https://packagist.org/downloads/",
+ "license": [
+ "BSD-2-Clause"
+ ],
+ "authors": [
+ {
+ "name": "Zaahid Bateson"
+ }
+ ],
+ "description": "Wrapper for mbstring with fallback to iconv for encoding conversion and string manipulation",
+ "homepage": "https://github.com/zbateson/StreamDecorators",
+ "keywords": [
+ "charset",
+ "encoding",
+ "http",
+ "iconv",
+ "mail",
+ "mb",
+ "mb_convert_encoding",
+ "mbstring",
+ "mime",
+ "multibyte",
+ "string"
+ ],
+ "time": "2018-09-28T17:43:01+00:00"
+ }
+ ],
+ "packages-dev": [
+ {
+ "name": "doctrine/instantiator",
+ "version": "1.3.0",
+ "source": {
+ "type": "git",
+ "url": "https://github.com/doctrine/instantiator.git",
+ "reference": "ae466f726242e637cebdd526a7d991b9433bacf1"
+ },
+ "dist": {
+ "type": "zip",
+ "url": "https://api.github.com/repos/doctrine/instantiator/zipball/ae466f726242e637cebdd526a7d991b9433bacf1",
+ "reference": "ae466f726242e637cebdd526a7d991b9433bacf1",
+ "shasum": ""
+ },
+ "require": {
+ "php": "^7.1"
+ },
+ "require-dev": {
+ "doctrine/coding-standard": "^6.0",
+ "ext-pdo": "*",
+ "ext-phar": "*",
+ "phpbench/phpbench": "^0.13",
+ "phpstan/phpstan-phpunit": "^0.11",
+ "phpstan/phpstan-shim": "^0.11",
+ "phpunit/phpunit": "^7.0"
+ },
+ "type": "library",
+ "extra": {
+ "branch-alias": {
+ "dev-master": "1.2.x-dev"
+ }
+ },
+ "autoload": {
+ "psr-4": {
+ "Doctrine\\Instantiator\\": "src/Doctrine/Instantiator/"
+ }
+ },
+ "notification-url": "https://packagist.org/downloads/",
+ "license": [
+ "MIT"
+ ],
+ "authors": [
+ {
+ "name": "Marco Pivetta",
+ "email": "ocramius@gmail.com",
+ "homepage": "http://ocramius.github.com/"
+ }
+ ],
+ "description": "A small, lightweight utility to instantiate objects in PHP without invoking their constructors",
+ "homepage": "https://www.doctrine-project.org/projects/instantiator.html",
+ "keywords": [
+ "constructor",
+ "instantiate"
+ ],
+ "time": "2019-10-21T16:45:58+00:00"
+ },
+ {
+ "name": "myclabs/deep-copy",
+ "version": "1.9.5",
+ "source": {
+ "type": "git",
+ "url": "https://github.com/myclabs/DeepCopy.git",
+ "reference": "b2c28789e80a97badd14145fda39b545d83ca3ef"
+ },
+ "dist": {
+ "type": "zip",
+ "url": "https://api.github.com/repos/myclabs/DeepCopy/zipball/b2c28789e80a97badd14145fda39b545d83ca3ef",
+ "reference": "b2c28789e80a97badd14145fda39b545d83ca3ef",
+ "shasum": ""
+ },
+ "require": {
+ "php": "^7.1"
+ },
+ "replace": {
+ "myclabs/deep-copy": "self.version"
+ },
+ "require-dev": {
+ "doctrine/collections": "^1.0",
+ "doctrine/common": "^2.6",
+ "phpunit/phpunit": "^7.1"
+ },
+ "type": "library",
+ "autoload": {
+ "psr-4": {
+ "DeepCopy\\": "src/DeepCopy/"
+ },
+ "files": [
+ "src/DeepCopy/deep_copy.php"
+ ]
+ },
+ "notification-url": "https://packagist.org/downloads/",
+ "license": [
+ "MIT"
+ ],
+ "description": "Create deep copies (clones) of your objects",
+ "keywords": [
+ "clone",
+ "copy",
+ "duplicate",
+ "object",
+ "object graph"
+ ],
+ "time": "2020-01-17T21:11:47+00:00"
+ },
+ {
+ "name": "phar-io/manifest",
+ "version": "1.0.3",
+ "source": {
+ "type": "git",
+ "url": "https://github.com/phar-io/manifest.git",
+ "reference": "7761fcacf03b4d4f16e7ccb606d4879ca431fcf4"
+ },
+ "dist": {
+ "type": "zip",
+ "url": "https://api.github.com/repos/phar-io/manifest/zipball/7761fcacf03b4d4f16e7ccb606d4879ca431fcf4",
+ "reference": "7761fcacf03b4d4f16e7ccb606d4879ca431fcf4",
+ "shasum": ""
+ },
+ "require": {
+ "ext-dom": "*",
+ "ext-phar": "*",
+ "phar-io/version": "^2.0",
+ "php": "^5.6 || ^7.0"
+ },
+ "type": "library",
+ "extra": {
+ "branch-alias": {
+ "dev-master": "1.0.x-dev"
+ }
+ },
+ "autoload": {
+ "classmap": [
+ "src/"
+ ]
+ },
+ "notification-url": "https://packagist.org/downloads/",
+ "license": [
+ "BSD-3-Clause"
+ ],
+ "authors": [
+ {
+ "name": "Arne Blankerts",
+ "email": "arne@blankerts.de",
+ "role": "Developer"
+ },
+ {
+ "name": "Sebastian Heuer",
+ "email": "sebastian@phpeople.de",
+ "role": "Developer"
+ },
+ {
+ "name": "Sebastian Bergmann",
+ "email": "sebastian@phpunit.de",
+ "role": "Developer"
+ }
+ ],
+ "description": "Component for reading phar.io manifest information from a PHP Archive (PHAR)",
+ "time": "2018-07-08T19:23:20+00:00"
+ },
+ {
+ "name": "phar-io/version",
+ "version": "2.0.1",
+ "source": {
+ "type": "git",
+ "url": "https://github.com/phar-io/version.git",
+ "reference": "45a2ec53a73c70ce41d55cedef9063630abaf1b6"
+ },
+ "dist": {
+ "type": "zip",
+ "url": "https://api.github.com/repos/phar-io/version/zipball/45a2ec53a73c70ce41d55cedef9063630abaf1b6",
+ "reference": "45a2ec53a73c70ce41d55cedef9063630abaf1b6",
+ "shasum": ""
+ },
+ "require": {
+ "php": "^5.6 || ^7.0"
+ },
+ "type": "library",
+ "autoload": {
+ "classmap": [
+ "src/"
+ ]
+ },
+ "notification-url": "https://packagist.org/downloads/",
+ "license": [
+ "BSD-3-Clause"
+ ],
+ "authors": [
+ {
+ "name": "Arne Blankerts",
+ "email": "arne@blankerts.de",
+ "role": "Developer"
+ },
+ {
+ "name": "Sebastian Heuer",
+ "email": "sebastian@phpeople.de",
+ "role": "Developer"
+ },
+ {
+ "name": "Sebastian Bergmann",
+ "email": "sebastian@phpunit.de",
+ "role": "Developer"
+ }
+ ],
+ "description": "Library for handling version information and constraints",
+ "time": "2018-07-08T19:19:57+00:00"
+ },
+ {
+ "name": "phpdocumentor/reflection-common",
+ "version": "2.0.0",
+ "source": {
+ "type": "git",
+ "url": "https://github.com/phpDocumentor/ReflectionCommon.git",
+ "reference": "63a995caa1ca9e5590304cd845c15ad6d482a62a"
+ },
+ "dist": {
+ "type": "zip",
+ "url": "https://api.github.com/repos/phpDocumentor/ReflectionCommon/zipball/63a995caa1ca9e5590304cd845c15ad6d482a62a",
+ "reference": "63a995caa1ca9e5590304cd845c15ad6d482a62a",
+ "shasum": ""
+ },
+ "require": {
+ "php": ">=7.1"
+ },
+ "require-dev": {
+ "phpunit/phpunit": "~6"
+ },
+ "type": "library",
+ "extra": {
+ "branch-alias": {
+ "dev-master": "2.x-dev"
+ }
+ },
+ "autoload": {
+ "psr-4": {
+ "phpDocumentor\\Reflection\\": "src/"
+ }
+ },
+ "notification-url": "https://packagist.org/downloads/",
+ "license": [
+ "MIT"
+ ],
+ "authors": [
+ {
+ "name": "Jaap van Otterdijk",
+ "email": "opensource@ijaap.nl"
+ }
+ ],
+ "description": "Common reflection classes used by phpdocumentor to reflect the code structure",
+ "homepage": "http://www.phpdoc.org",
+ "keywords": [
+ "FQSEN",
+ "phpDocumentor",
+ "phpdoc",
+ "reflection",
+ "static analysis"
+ ],
+ "time": "2018-08-07T13:53:10+00:00"
+ },
+ {
+ "name": "phpdocumentor/reflection-docblock",
+ "version": "5.0.0",
+ "source": {
+ "type": "git",
+ "url": "https://github.com/phpDocumentor/ReflectionDocBlock.git",
+ "reference": "a48807183a4b819072f26e347bbd0b5199a9d15f"
+ },
+ "dist": {
+ "type": "zip",
+ "url": "https://api.github.com/repos/phpDocumentor/ReflectionDocBlock/zipball/a48807183a4b819072f26e347bbd0b5199a9d15f",
+ "reference": "a48807183a4b819072f26e347bbd0b5199a9d15f",
+ "shasum": ""
+ },
+ "require": {
+ "ext-filter": "^7.1",
+ "php": "^7.2",
+ "phpdocumentor/reflection-common": "^2.0",
+ "phpdocumentor/type-resolver": "^1.0",
+ "webmozart/assert": "^1"
+ },
+ "require-dev": {
+ "doctrine/instantiator": "^1",
+ "mockery/mockery": "^1"
+ },
+ "type": "library",
+ "extra": {
+ "branch-alias": {
+ "dev-master": "5.x-dev"
+ }
+ },
+ "autoload": {
+ "psr-4": {
+ "phpDocumentor\\Reflection\\": "src"
+ }
+ },
+ "notification-url": "https://packagist.org/downloads/",
+ "license": [
+ "MIT"
+ ],
+ "authors": [
+ {
+ "name": "Mike van Riel",
+ "email": "me@mikevanriel.com"
+ },
+ {
+ "name": "Jaap van Otterdijk",
+ "email": "account@ijaap.nl"
+ }
+ ],
+ "description": "With this component, a library can provide support for annotations via DocBlocks or otherwise retrieve information that is embedded in a DocBlock.",
+ "time": "2020-02-09T09:16:15+00:00"
+ },
+ {
+ "name": "phpdocumentor/type-resolver",
+ "version": "1.0.1",
+ "source": {
+ "type": "git",
+ "url": "https://github.com/phpDocumentor/TypeResolver.git",
+ "reference": "2e32a6d48972b2c1976ed5d8967145b6cec4a4a9"
+ },
+ "dist": {
+ "type": "zip",
+ "url": "https://api.github.com/repos/phpDocumentor/TypeResolver/zipball/2e32a6d48972b2c1976ed5d8967145b6cec4a4a9",
+ "reference": "2e32a6d48972b2c1976ed5d8967145b6cec4a4a9",
+ "shasum": ""
+ },
+ "require": {
+ "php": "^7.1",
+ "phpdocumentor/reflection-common": "^2.0"
+ },
+ "require-dev": {
+ "ext-tokenizer": "^7.1",
+ "mockery/mockery": "~1",
+ "phpunit/phpunit": "^7.0"
+ },
+ "type": "library",
+ "extra": {
+ "branch-alias": {
+ "dev-master": "1.x-dev"
+ }
+ },
+ "autoload": {
+ "psr-4": {
+ "phpDocumentor\\Reflection\\": "src"
+ }
+ },
+ "notification-url": "https://packagist.org/downloads/",
+ "license": [
+ "MIT"
+ ],
+ "authors": [
+ {
+ "name": "Mike van Riel",
+ "email": "me@mikevanriel.com"
+ }
+ ],
+ "description": "A PSR-5 based resolver of Class names, Types and Structural Element Names",
+ "time": "2019-08-22T18:11:29+00:00"
+ },
+ {
+ "name": "phpspec/prophecy",
+ "version": "v1.10.2",
+ "source": {
+ "type": "git",
+ "url": "https://github.com/phpspec/prophecy.git",
+ "reference": "b4400efc9d206e83138e2bb97ed7f5b14b831cd9"
+ },
+ "dist": {
+ "type": "zip",
+ "url": "https://api.github.com/repos/phpspec/prophecy/zipball/b4400efc9d206e83138e2bb97ed7f5b14b831cd9",
+ "reference": "b4400efc9d206e83138e2bb97ed7f5b14b831cd9",
+ "shasum": ""
+ },
+ "require": {
+ "doctrine/instantiator": "^1.0.2",
+ "php": "^5.3|^7.0",
+ "phpdocumentor/reflection-docblock": "^2.0|^3.0.2|^4.0|^5.0",
+ "sebastian/comparator": "^1.2.3|^2.0|^3.0|^4.0",
+ "sebastian/recursion-context": "^1.0|^2.0|^3.0|^4.0"
+ },
+ "require-dev": {
+ "phpspec/phpspec": "^2.5 || ^3.2",
+ "phpunit/phpunit": "^4.8.35 || ^5.7 || ^6.5 || ^7.1"
+ },
+ "type": "library",
+ "extra": {
+ "branch-alias": {
+ "dev-master": "1.10.x-dev"
+ }
+ },
+ "autoload": {
+ "psr-4": {
+ "Prophecy\\": "src/Prophecy"
+ }
+ },
+ "notification-url": "https://packagist.org/downloads/",
+ "license": [
+ "MIT"
+ ],
+ "authors": [
+ {
+ "name": "Konstantin Kudryashov",
+ "email": "ever.zet@gmail.com",
+ "homepage": "http://everzet.com"
+ },
+ {
+ "name": "Marcello Duarte",
+ "email": "marcello.duarte@gmail.com"
+ }
+ ],
+ "description": "Highly opinionated mocking framework for PHP 5.3+",
+ "homepage": "https://github.com/phpspec/prophecy",
+ "keywords": [
+ "Double",
+ "Dummy",
+ "fake",
+ "mock",
+ "spy",
+ "stub"
+ ],
+ "time": "2020-01-20T15:57:02+00:00"
+ },
+ {
+ "name": "phpunit/php-code-coverage",
+ "version": "6.1.4",
+ "source": {
+ "type": "git",
+ "url": "https://github.com/sebastianbergmann/php-code-coverage.git",
+ "reference": "807e6013b00af69b6c5d9ceb4282d0393dbb9d8d"
+ },
+ "dist": {
+ "type": "zip",
+ "url": "https://api.github.com/repos/sebastianbergmann/php-code-coverage/zipball/807e6013b00af69b6c5d9ceb4282d0393dbb9d8d",
+ "reference": "807e6013b00af69b6c5d9ceb4282d0393dbb9d8d",
+ "shasum": ""
+ },
+ "require": {
+ "ext-dom": "*",
+ "ext-xmlwriter": "*",
+ "php": "^7.1",
+ "phpunit/php-file-iterator": "^2.0",
+ "phpunit/php-text-template": "^1.2.1",
+ "phpunit/php-token-stream": "^3.0",
+ "sebastian/code-unit-reverse-lookup": "^1.0.1",
+ "sebastian/environment": "^3.1 || ^4.0",
+ "sebastian/version": "^2.0.1",
+ "theseer/tokenizer": "^1.1"
+ },
+ "require-dev": {
+ "phpunit/phpunit": "^7.0"
+ },
+ "suggest": {
+ "ext-xdebug": "^2.6.0"
+ },
+ "type": "library",
+ "extra": {
+ "branch-alias": {
+ "dev-master": "6.1-dev"
+ }
+ },
+ "autoload": {
+ "classmap": [
+ "src/"
+ ]
+ },
+ "notification-url": "https://packagist.org/downloads/",
+ "license": [
+ "BSD-3-Clause"
+ ],
+ "authors": [
+ {
+ "name": "Sebastian Bergmann",
+ "email": "sebastian@phpunit.de",
+ "role": "lead"
+ }
+ ],
+ "description": "Library that provides collection, processing, and rendering functionality for PHP code coverage information.",
+ "homepage": "https://github.com/sebastianbergmann/php-code-coverage",
+ "keywords": [
+ "coverage",
+ "testing",
+ "xunit"
+ ],
+ "time": "2018-10-31T16:06:48+00:00"
+ },
+ {
+ "name": "phpunit/php-file-iterator",
+ "version": "2.0.2",
+ "source": {
+ "type": "git",
+ "url": "https://github.com/sebastianbergmann/php-file-iterator.git",
+ "reference": "050bedf145a257b1ff02746c31894800e5122946"
+ },
+ "dist": {
+ "type": "zip",
+ "url": "https://api.github.com/repos/sebastianbergmann/php-file-iterator/zipball/050bedf145a257b1ff02746c31894800e5122946",
+ "reference": "050bedf145a257b1ff02746c31894800e5122946",
+ "shasum": ""
+ },
+ "require": {
+ "php": "^7.1"
+ },
+ "require-dev": {
+ "phpunit/phpunit": "^7.1"
+ },
+ "type": "library",
+ "extra": {
+ "branch-alias": {
+ "dev-master": "2.0.x-dev"
+ }
+ },
+ "autoload": {
+ "classmap": [
+ "src/"
+ ]
+ },
+ "notification-url": "https://packagist.org/downloads/",
+ "license": [
+ "BSD-3-Clause"
+ ],
+ "authors": [
+ {
+ "name": "Sebastian Bergmann",
+ "email": "sebastian@phpunit.de",
+ "role": "lead"
+ }
+ ],
+ "description": "FilterIterator implementation that filters files based on a list of suffixes.",
+ "homepage": "https://github.com/sebastianbergmann/php-file-iterator/",
+ "keywords": [
+ "filesystem",
+ "iterator"
+ ],
+ "time": "2018-09-13T20:33:42+00:00"
+ },
+ {
+ "name": "phpunit/php-text-template",
+ "version": "1.2.1",
+ "source": {
+ "type": "git",
+ "url": "https://github.com/sebastianbergmann/php-text-template.git",
+ "reference": "31f8b717e51d9a2afca6c9f046f5d69fc27c8686"
+ },
+ "dist": {
+ "type": "zip",
+ "url": "https://api.github.com/repos/sebastianbergmann/php-text-template/zipball/31f8b717e51d9a2afca6c9f046f5d69fc27c8686",
+ "reference": "31f8b717e51d9a2afca6c9f046f5d69fc27c8686",
+ "shasum": ""
+ },
+ "require": {
+ "php": ">=5.3.3"
+ },
+ "type": "library",
+ "autoload": {
+ "classmap": [
+ "src/"
+ ]
+ },
+ "notification-url": "https://packagist.org/downloads/",
+ "license": [
+ "BSD-3-Clause"
+ ],
+ "authors": [
+ {
+ "name": "Sebastian Bergmann",
+ "email": "sebastian@phpunit.de",
+ "role": "lead"
+ }
+ ],
+ "description": "Simple template engine.",
+ "homepage": "https://github.com/sebastianbergmann/php-text-template/",
+ "keywords": [
+ "template"
+ ],
+ "time": "2015-06-21T13:50:34+00:00"
+ },
+ {
+ "name": "phpunit/php-timer",
+ "version": "2.1.2",
+ "source": {
+ "type": "git",
+ "url": "https://github.com/sebastianbergmann/php-timer.git",
+ "reference": "1038454804406b0b5f5f520358e78c1c2f71501e"
+ },
+ "dist": {
+ "type": "zip",
+ "url": "https://api.github.com/repos/sebastianbergmann/php-timer/zipball/1038454804406b0b5f5f520358e78c1c2f71501e",
+ "reference": "1038454804406b0b5f5f520358e78c1c2f71501e",
+ "shasum": ""
+ },
+ "require": {
+ "php": "^7.1"
+ },
+ "require-dev": {
+ "phpunit/phpunit": "^7.0"
+ },
+ "type": "library",
+ "extra": {
+ "branch-alias": {
+ "dev-master": "2.1-dev"
+ }
+ },
+ "autoload": {
+ "classmap": [
+ "src/"
+ ]
+ },
+ "notification-url": "https://packagist.org/downloads/",
+ "license": [
+ "BSD-3-Clause"
+ ],
+ "authors": [
+ {
+ "name": "Sebastian Bergmann",
+ "email": "sebastian@phpunit.de",
+ "role": "lead"
+ }
+ ],
+ "description": "Utility class for timing",
+ "homepage": "https://github.com/sebastianbergmann/php-timer/",
+ "keywords": [
+ "timer"
+ ],
+ "time": "2019-06-07T04:22:29+00:00"
+ },
+ {
+ "name": "phpunit/php-token-stream",
+ "version": "3.1.1",
+ "source": {
+ "type": "git",
+ "url": "https://github.com/sebastianbergmann/php-token-stream.git",
+ "reference": "995192df77f63a59e47f025390d2d1fdf8f425ff"
+ },
+ "dist": {
+ "type": "zip",
+ "url": "https://api.github.com/repos/sebastianbergmann/php-token-stream/zipball/995192df77f63a59e47f025390d2d1fdf8f425ff",
+ "reference": "995192df77f63a59e47f025390d2d1fdf8f425ff",
+ "shasum": ""
+ },
+ "require": {
+ "ext-tokenizer": "*",
+ "php": "^7.1"
+ },
+ "require-dev": {
+ "phpunit/phpunit": "^7.0"
+ },
+ "type": "library",
+ "extra": {
+ "branch-alias": {
+ "dev-master": "3.1-dev"
+ }
+ },
+ "autoload": {
+ "classmap": [
+ "src/"
+ ]
+ },
+ "notification-url": "https://packagist.org/downloads/",
+ "license": [
+ "BSD-3-Clause"
+ ],
+ "authors": [
+ {
+ "name": "Sebastian Bergmann",
+ "email": "sebastian@phpunit.de"
+ }
+ ],
+ "description": "Wrapper around PHP's tokenizer extension.",
+ "homepage": "https://github.com/sebastianbergmann/php-token-stream/",
+ "keywords": [
+ "tokenizer"
+ ],
+ "time": "2019-09-17T06:23:10+00:00"
+ },
+ {
+ "name": "phpunit/phpunit",
+ "version": "7.5.20",
+ "source": {
+ "type": "git",
+ "url": "https://github.com/sebastianbergmann/phpunit.git",
+ "reference": "9467db479d1b0487c99733bb1e7944d32deded2c"
+ },
+ "dist": {
+ "type": "zip",
+ "url": "https://api.github.com/repos/sebastianbergmann/phpunit/zipball/9467db479d1b0487c99733bb1e7944d32deded2c",
+ "reference": "9467db479d1b0487c99733bb1e7944d32deded2c",
+ "shasum": ""
+ },
+ "require": {
+ "doctrine/instantiator": "^1.1",
+ "ext-dom": "*",
+ "ext-json": "*",
+ "ext-libxml": "*",
+ "ext-mbstring": "*",
+ "ext-xml": "*",
+ "myclabs/deep-copy": "^1.7",
+ "phar-io/manifest": "^1.0.2",
+ "phar-io/version": "^2.0",
+ "php": "^7.1",
+ "phpspec/prophecy": "^1.7",
+ "phpunit/php-code-coverage": "^6.0.7",
+ "phpunit/php-file-iterator": "^2.0.1",
+ "phpunit/php-text-template": "^1.2.1",
+ "phpunit/php-timer": "^2.1",
+ "sebastian/comparator": "^3.0",
+ "sebastian/diff": "^3.0",
+ "sebastian/environment": "^4.0",
+ "sebastian/exporter": "^3.1",
+ "sebastian/global-state": "^2.0",
+ "sebastian/object-enumerator": "^3.0.3",
+ "sebastian/resource-operations": "^2.0",
+ "sebastian/version": "^2.0.1"
+ },
+ "conflict": {
+ "phpunit/phpunit-mock-objects": "*"
+ },
+ "require-dev": {
+ "ext-pdo": "*"
+ },
+ "suggest": {
+ "ext-soap": "*",
+ "ext-xdebug": "*",
+ "phpunit/php-invoker": "^2.0"
+ },
+ "bin": [
+ "phpunit"
+ ],
+ "type": "library",
+ "extra": {
+ "branch-alias": {
+ "dev-master": "7.5-dev"
+ }
+ },
+ "autoload": {
+ "classmap": [
+ "src/"
+ ]
+ },
+ "notification-url": "https://packagist.org/downloads/",
+ "license": [
+ "BSD-3-Clause"
+ ],
+ "authors": [
+ {
+ "name": "Sebastian Bergmann",
+ "email": "sebastian@phpunit.de",
+ "role": "lead"
+ }
+ ],
+ "description": "The PHP Unit Testing framework.",
+ "homepage": "https://phpunit.de/",
+ "keywords": [
+ "phpunit",
+ "testing",
+ "xunit"
+ ],
+ "time": "2020-01-08T08:45:45+00:00"
+ },
+ {
+ "name": "sebastian/code-unit-reverse-lookup",
+ "version": "1.0.1",
+ "source": {
+ "type": "git",
+ "url": "https://github.com/sebastianbergmann/code-unit-reverse-lookup.git",
+ "reference": "4419fcdb5eabb9caa61a27c7a1db532a6b55dd18"
+ },
+ "dist": {
+ "type": "zip",
+ "url": "https://api.github.com/repos/sebastianbergmann/code-unit-reverse-lookup/zipball/4419fcdb5eabb9caa61a27c7a1db532a6b55dd18",
+ "reference": "4419fcdb5eabb9caa61a27c7a1db532a6b55dd18",
+ "shasum": ""
+ },
+ "require": {
+ "php": "^5.6 || ^7.0"
+ },
+ "require-dev": {
+ "phpunit/phpunit": "^5.7 || ^6.0"
+ },
+ "type": "library",
+ "extra": {
+ "branch-alias": {
+ "dev-master": "1.0.x-dev"
+ }
+ },
+ "autoload": {
+ "classmap": [
+ "src/"
+ ]
+ },
+ "notification-url": "https://packagist.org/downloads/",
+ "license": [
+ "BSD-3-Clause"
+ ],
+ "authors": [
+ {
+ "name": "Sebastian Bergmann",
+ "email": "sebastian@phpunit.de"
+ }
+ ],
+ "description": "Looks up which function or method a line of code belongs to",
+ "homepage": "https://github.com/sebastianbergmann/code-unit-reverse-lookup/",
+ "time": "2017-03-04T06:30:41+00:00"
+ },
+ {
+ "name": "sebastian/comparator",
+ "version": "3.0.2",
+ "source": {
+ "type": "git",
+ "url": "https://github.com/sebastianbergmann/comparator.git",
+ "reference": "5de4fc177adf9bce8df98d8d141a7559d7ccf6da"
+ },
+ "dist": {
+ "type": "zip",
+ "url": "https://api.github.com/repos/sebastianbergmann/comparator/zipball/5de4fc177adf9bce8df98d8d141a7559d7ccf6da",
+ "reference": "5de4fc177adf9bce8df98d8d141a7559d7ccf6da",
+ "shasum": ""
+ },
+ "require": {
+ "php": "^7.1",
+ "sebastian/diff": "^3.0",
+ "sebastian/exporter": "^3.1"
+ },
+ "require-dev": {
+ "phpunit/phpunit": "^7.1"
+ },
+ "type": "library",
+ "extra": {
+ "branch-alias": {
+ "dev-master": "3.0-dev"
+ }
+ },
+ "autoload": {
+ "classmap": [
+ "src/"
+ ]
+ },
+ "notification-url": "https://packagist.org/downloads/",
+ "license": [
+ "BSD-3-Clause"
+ ],
+ "authors": [
+ {
+ "name": "Jeff Welch",
+ "email": "whatthejeff@gmail.com"
+ },
+ {
+ "name": "Volker Dusch",
+ "email": "github@wallbash.com"
+ },
+ {
+ "name": "Bernhard Schussek",
+ "email": "bschussek@2bepublished.at"
+ },
+ {
+ "name": "Sebastian Bergmann",
+ "email": "sebastian@phpunit.de"
+ }
+ ],
+ "description": "Provides the functionality to compare PHP values for equality",
+ "homepage": "https://github.com/sebastianbergmann/comparator",
+ "keywords": [
+ "comparator",
+ "compare",
+ "equality"
+ ],
+ "time": "2018-07-12T15:12:46+00:00"
+ },
+ {
+ "name": "sebastian/diff",
+ "version": "3.0.2",
+ "source": {
+ "type": "git",
+ "url": "https://github.com/sebastianbergmann/diff.git",
+ "reference": "720fcc7e9b5cf384ea68d9d930d480907a0c1a29"
+ },
+ "dist": {
+ "type": "zip",
+ "url": "https://api.github.com/repos/sebastianbergmann/diff/zipball/720fcc7e9b5cf384ea68d9d930d480907a0c1a29",
+ "reference": "720fcc7e9b5cf384ea68d9d930d480907a0c1a29",
+ "shasum": ""
+ },
+ "require": {
+ "php": "^7.1"
+ },
+ "require-dev": {
+ "phpunit/phpunit": "^7.5 || ^8.0",
+ "symfony/process": "^2 || ^3.3 || ^4"
+ },
+ "type": "library",
+ "extra": {
+ "branch-alias": {
+ "dev-master": "3.0-dev"
+ }
+ },
+ "autoload": {
+ "classmap": [
+ "src/"
+ ]
+ },
+ "notification-url": "https://packagist.org/downloads/",
+ "license": [
+ "BSD-3-Clause"
+ ],
+ "authors": [
+ {
+ "name": "Kore Nordmann",
+ "email": "mail@kore-nordmann.de"
+ },
+ {
+ "name": "Sebastian Bergmann",
+ "email": "sebastian@phpunit.de"
+ }
+ ],
+ "description": "Diff implementation",
+ "homepage": "https://github.com/sebastianbergmann/diff",
+ "keywords": [
+ "diff",
+ "udiff",
+ "unidiff",
+ "unified diff"
+ ],
+ "time": "2019-02-04T06:01:07+00:00"
+ },
+ {
+ "name": "sebastian/environment",
+ "version": "4.2.3",
+ "source": {
+ "type": "git",
+ "url": "https://github.com/sebastianbergmann/environment.git",
+ "reference": "464c90d7bdf5ad4e8a6aea15c091fec0603d4368"
+ },
+ "dist": {
+ "type": "zip",
+ "url": "https://api.github.com/repos/sebastianbergmann/environment/zipball/464c90d7bdf5ad4e8a6aea15c091fec0603d4368",
+ "reference": "464c90d7bdf5ad4e8a6aea15c091fec0603d4368",
+ "shasum": ""
+ },
+ "require": {
+ "php": "^7.1"
+ },
+ "require-dev": {
+ "phpunit/phpunit": "^7.5"
+ },
+ "suggest": {
+ "ext-posix": "*"
+ },
+ "type": "library",
+ "extra": {
+ "branch-alias": {
+ "dev-master": "4.2-dev"
+ }
+ },
+ "autoload": {
+ "classmap": [
+ "src/"
+ ]
+ },
+ "notification-url": "https://packagist.org/downloads/",
+ "license": [
+ "BSD-3-Clause"
+ ],
+ "authors": [
+ {
+ "name": "Sebastian Bergmann",
+ "email": "sebastian@phpunit.de"
+ }
+ ],
+ "description": "Provides functionality to handle HHVM/PHP environments",
+ "homepage": "http://www.github.com/sebastianbergmann/environment",
+ "keywords": [
+ "Xdebug",
+ "environment",
+ "hhvm"
+ ],
+ "time": "2019-11-20T08:46:58+00:00"
+ },
+ {
+ "name": "sebastian/exporter",
+ "version": "3.1.2",
+ "source": {
+ "type": "git",
+ "url": "https://github.com/sebastianbergmann/exporter.git",
+ "reference": "68609e1261d215ea5b21b7987539cbfbe156ec3e"
+ },
+ "dist": {
+ "type": "zip",
+ "url": "https://api.github.com/repos/sebastianbergmann/exporter/zipball/68609e1261d215ea5b21b7987539cbfbe156ec3e",
+ "reference": "68609e1261d215ea5b21b7987539cbfbe156ec3e",
+ "shasum": ""
+ },
+ "require": {
+ "php": "^7.0",
+ "sebastian/recursion-context": "^3.0"
+ },
+ "require-dev": {
+ "ext-mbstring": "*",
+ "phpunit/phpunit": "^6.0"
+ },
+ "type": "library",
+ "extra": {
+ "branch-alias": {
+ "dev-master": "3.1.x-dev"
+ }
+ },
+ "autoload": {
+ "classmap": [
+ "src/"
+ ]
+ },
+ "notification-url": "https://packagist.org/downloads/",
+ "license": [
+ "BSD-3-Clause"
+ ],
+ "authors": [
+ {
+ "name": "Sebastian Bergmann",
+ "email": "sebastian@phpunit.de"
+ },
+ {
+ "name": "Jeff Welch",
+ "email": "whatthejeff@gmail.com"
+ },
+ {
+ "name": "Volker Dusch",
+ "email": "github@wallbash.com"
+ },
+ {
+ "name": "Adam Harvey",
+ "email": "aharvey@php.net"
+ },
+ {
+ "name": "Bernhard Schussek",
+ "email": "bschussek@gmail.com"
+ }
+ ],
+ "description": "Provides the functionality to export PHP variables for visualization",
+ "homepage": "http://www.github.com/sebastianbergmann/exporter",
+ "keywords": [
+ "export",
+ "exporter"
+ ],
+ "time": "2019-09-14T09:02:43+00:00"
+ },
+ {
+ "name": "sebastian/global-state",
+ "version": "2.0.0",
+ "source": {
+ "type": "git",
+ "url": "https://github.com/sebastianbergmann/global-state.git",
+ "reference": "e8ba02eed7bbbb9e59e43dedd3dddeff4a56b0c4"
+ },
+ "dist": {
+ "type": "zip",
+ "url": "https://api.github.com/repos/sebastianbergmann/global-state/zipball/e8ba02eed7bbbb9e59e43dedd3dddeff4a56b0c4",
+ "reference": "e8ba02eed7bbbb9e59e43dedd3dddeff4a56b0c4",
+ "shasum": ""
+ },
+ "require": {
+ "php": "^7.0"
+ },
+ "require-dev": {
+ "phpunit/phpunit": "^6.0"
+ },
+ "suggest": {
+ "ext-uopz": "*"
+ },
+ "type": "library",
+ "extra": {
+ "branch-alias": {
+ "dev-master": "2.0-dev"
+ }
+ },
+ "autoload": {
+ "classmap": [
+ "src/"
+ ]
+ },
+ "notification-url": "https://packagist.org/downloads/",
+ "license": [
+ "BSD-3-Clause"
+ ],
+ "authors": [
+ {
+ "name": "Sebastian Bergmann",
+ "email": "sebastian@phpunit.de"
+ }
+ ],
+ "description": "Snapshotting of global state",
+ "homepage": "http://www.github.com/sebastianbergmann/global-state",
+ "keywords": [
+ "global state"
+ ],
+ "time": "2017-04-27T15:39:26+00:00"
+ },
+ {
+ "name": "sebastian/object-enumerator",
+ "version": "3.0.3",
+ "source": {
+ "type": "git",
+ "url": "https://github.com/sebastianbergmann/object-enumerator.git",
+ "reference": "7cfd9e65d11ffb5af41198476395774d4c8a84c5"
+ },
+ "dist": {
+ "type": "zip",
+ "url": "https://api.github.com/repos/sebastianbergmann/object-enumerator/zipball/7cfd9e65d11ffb5af41198476395774d4c8a84c5",
+ "reference": "7cfd9e65d11ffb5af41198476395774d4c8a84c5",
+ "shasum": ""
+ },
+ "require": {
+ "php": "^7.0",
+ "sebastian/object-reflector": "^1.1.1",
+ "sebastian/recursion-context": "^3.0"
+ },
+ "require-dev": {
+ "phpunit/phpunit": "^6.0"
+ },
+ "type": "library",
+ "extra": {
+ "branch-alias": {
+ "dev-master": "3.0.x-dev"
+ }
+ },
+ "autoload": {
+ "classmap": [
+ "src/"
+ ]
+ },
+ "notification-url": "https://packagist.org/downloads/",
+ "license": [
+ "BSD-3-Clause"
+ ],
+ "authors": [
+ {
+ "name": "Sebastian Bergmann",
+ "email": "sebastian@phpunit.de"
+ }
+ ],
+ "description": "Traverses array structures and object graphs to enumerate all referenced objects",
+ "homepage": "https://github.com/sebastianbergmann/object-enumerator/",
+ "time": "2017-08-03T12:35:26+00:00"
+ },
+ {
+ "name": "sebastian/object-reflector",
+ "version": "1.1.1",
+ "source": {
+ "type": "git",
+ "url": "https://github.com/sebastianbergmann/object-reflector.git",
+ "reference": "773f97c67f28de00d397be301821b06708fca0be"
+ },
+ "dist": {
+ "type": "zip",
+ "url": "https://api.github.com/repos/sebastianbergmann/object-reflector/zipball/773f97c67f28de00d397be301821b06708fca0be",
+ "reference": "773f97c67f28de00d397be301821b06708fca0be",
+ "shasum": ""
+ },
+ "require": {
+ "php": "^7.0"
+ },
+ "require-dev": {
+ "phpunit/phpunit": "^6.0"
+ },
+ "type": "library",
+ "extra": {
+ "branch-alias": {
+ "dev-master": "1.1-dev"
+ }
+ },
+ "autoload": {
+ "classmap": [
+ "src/"
+ ]
+ },
+ "notification-url": "https://packagist.org/downloads/",
+ "license": [
+ "BSD-3-Clause"
+ ],
+ "authors": [
+ {
+ "name": "Sebastian Bergmann",
+ "email": "sebastian@phpunit.de"
+ }
+ ],
+ "description": "Allows reflection of object attributes, including inherited and non-public ones",
+ "homepage": "https://github.com/sebastianbergmann/object-reflector/",
+ "time": "2017-03-29T09:07:27+00:00"
+ },
+ {
+ "name": "sebastian/recursion-context",
+ "version": "3.0.0",
+ "source": {
+ "type": "git",
+ "url": "https://github.com/sebastianbergmann/recursion-context.git",
+ "reference": "5b0cd723502bac3b006cbf3dbf7a1e3fcefe4fa8"
+ },
+ "dist": {
+ "type": "zip",
+ "url": "https://api.github.com/repos/sebastianbergmann/recursion-context/zipball/5b0cd723502bac3b006cbf3dbf7a1e3fcefe4fa8",
+ "reference": "5b0cd723502bac3b006cbf3dbf7a1e3fcefe4fa8",
+ "shasum": ""
+ },
+ "require": {
+ "php": "^7.0"
+ },
+ "require-dev": {
+ "phpunit/phpunit": "^6.0"
+ },
+ "type": "library",
+ "extra": {
+ "branch-alias": {
+ "dev-master": "3.0.x-dev"
+ }
+ },
+ "autoload": {
+ "classmap": [
+ "src/"
+ ]
+ },
+ "notification-url": "https://packagist.org/downloads/",
+ "license": [
+ "BSD-3-Clause"
+ ],
+ "authors": [
+ {
+ "name": "Jeff Welch",
+ "email": "whatthejeff@gmail.com"
+ },
+ {
+ "name": "Sebastian Bergmann",
+ "email": "sebastian@phpunit.de"
+ },
+ {
+ "name": "Adam Harvey",
+ "email": "aharvey@php.net"
+ }
+ ],
+ "description": "Provides functionality to recursively process PHP variables",
+ "homepage": "http://www.github.com/sebastianbergmann/recursion-context",
+ "time": "2017-03-03T06:23:57+00:00"
+ },
+ {
+ "name": "sebastian/resource-operations",
+ "version": "2.0.1",
+ "source": {
+ "type": "git",
+ "url": "https://github.com/sebastianbergmann/resource-operations.git",
+ "reference": "4d7a795d35b889bf80a0cc04e08d77cedfa917a9"
+ },
+ "dist": {
+ "type": "zip",
+ "url": "https://api.github.com/repos/sebastianbergmann/resource-operations/zipball/4d7a795d35b889bf80a0cc04e08d77cedfa917a9",
+ "reference": "4d7a795d35b889bf80a0cc04e08d77cedfa917a9",
+ "shasum": ""
+ },
+ "require": {
+ "php": "^7.1"
+ },
+ "type": "library",
+ "extra": {
+ "branch-alias": {
+ "dev-master": "2.0-dev"
+ }
+ },
+ "autoload": {
+ "classmap": [
+ "src/"
+ ]
+ },
+ "notification-url": "https://packagist.org/downloads/",
+ "license": [
+ "BSD-3-Clause"
+ ],
+ "authors": [
+ {
+ "name": "Sebastian Bergmann",
+ "email": "sebastian@phpunit.de"
+ }
+ ],
+ "description": "Provides a list of PHP built-in functions that operate on resources",
+ "homepage": "https://www.github.com/sebastianbergmann/resource-operations",
+ "time": "2018-10-04T04:07:39+00:00"
+ },
+ {
+ "name": "sebastian/version",
+ "version": "2.0.1",
+ "source": {
+ "type": "git",
+ "url": "https://github.com/sebastianbergmann/version.git",
+ "reference": "99732be0ddb3361e16ad77b68ba41efc8e979019"
+ },
+ "dist": {
+ "type": "zip",
+ "url": "https://api.github.com/repos/sebastianbergmann/version/zipball/99732be0ddb3361e16ad77b68ba41efc8e979019",
+ "reference": "99732be0ddb3361e16ad77b68ba41efc8e979019",
+ "shasum": ""
+ },
+ "require": {
+ "php": ">=5.6"
+ },
+ "type": "library",
+ "extra": {
+ "branch-alias": {
+ "dev-master": "2.0.x-dev"
+ }
+ },
+ "autoload": {
+ "classmap": [
+ "src/"
+ ]
+ },
+ "notification-url": "https://packagist.org/downloads/",
+ "license": [
+ "BSD-3-Clause"
+ ],
+ "authors": [
+ {
+ "name": "Sebastian Bergmann",
+ "email": "sebastian@phpunit.de",
+ "role": "lead"
+ }
+ ],
+ "description": "Library that helps with managing the version number of Git-hosted PHP projects",
+ "homepage": "https://github.com/sebastianbergmann/version",
+ "time": "2016-10-03T07:35:21+00:00"
+ },
+ {
+ "name": "symfony/polyfill-ctype",
+ "version": "v1.13.1",
+ "source": {
+ "type": "git",
+ "url": "https://github.com/symfony/polyfill-ctype.git",
+ "reference": "f8f0b461be3385e56d6de3dbb5a0df24c0c275e3"
+ },
+ "dist": {
+ "type": "zip",
+ "url": "https://api.github.com/repos/symfony/polyfill-ctype/zipball/f8f0b461be3385e56d6de3dbb5a0df24c0c275e3",
+ "reference": "f8f0b461be3385e56d6de3dbb5a0df24c0c275e3",
+ "shasum": ""
+ },
+ "require": {
+ "php": ">=5.3.3"
+ },
+ "suggest": {
+ "ext-ctype": "For best performance"
+ },
+ "type": "library",
+ "extra": {
+ "branch-alias": {
+ "dev-master": "1.13-dev"
+ }
+ },
+ "autoload": {
+ "psr-4": {
+ "Symfony\\Polyfill\\Ctype\\": ""
+ },
+ "files": [
+ "bootstrap.php"
+ ]
+ },
+ "notification-url": "https://packagist.org/downloads/",
+ "license": [
+ "MIT"
+ ],
+ "authors": [
+ {
+ "name": "Gert de Pagter",
+ "email": "BackEndTea@gmail.com"
+ },
+ {
+ "name": "Symfony Community",
+ "homepage": "https://symfony.com/contributors"
+ }
+ ],
+ "description": "Symfony polyfill for ctype functions",
+ "homepage": "https://symfony.com",
+ "keywords": [
+ "compatibility",
+ "ctype",
+ "polyfill",
+ "portable"
+ ],
+ "time": "2019-11-27T13:56:44+00:00"
+ },
+ {
+ "name": "theseer/tokenizer",
+ "version": "1.1.3",
+ "source": {
+ "type": "git",
+ "url": "https://github.com/theseer/tokenizer.git",
+ "reference": "11336f6f84e16a720dae9d8e6ed5019efa85a0f9"
+ },
+ "dist": {
+ "type": "zip",
+ "url": "https://api.github.com/repos/theseer/tokenizer/zipball/11336f6f84e16a720dae9d8e6ed5019efa85a0f9",
+ "reference": "11336f6f84e16a720dae9d8e6ed5019efa85a0f9",
+ "shasum": ""
+ },
+ "require": {
+ "ext-dom": "*",
+ "ext-tokenizer": "*",
+ "ext-xmlwriter": "*",
+ "php": "^7.0"
+ },
+ "type": "library",
+ "autoload": {
+ "classmap": [
+ "src/"
+ ]
+ },
+ "notification-url": "https://packagist.org/downloads/",
+ "license": [
+ "BSD-3-Clause"
+ ],
+ "authors": [
+ {
+ "name": "Arne Blankerts",
+ "email": "arne@blankerts.de",
+ "role": "Developer"
+ }
+ ],
+ "description": "A small library for converting tokenized PHP source code into XML and potentially other formats",
+ "time": "2019-06-13T22:48:21+00:00"
+ },
+ {
+ "name": "webmozart/assert",
+ "version": "1.6.0",
+ "source": {
+ "type": "git",
+ "url": "https://github.com/webmozart/assert.git",
+ "reference": "573381c0a64f155a0d9a23f4b0c797194805b925"
+ },
+ "dist": {
+ "type": "zip",
+ "url": "https://api.github.com/repos/webmozart/assert/zipball/573381c0a64f155a0d9a23f4b0c797194805b925",
+ "reference": "573381c0a64f155a0d9a23f4b0c797194805b925",
+ "shasum": ""
+ },
+ "require": {
+ "php": "^5.3.3 || ^7.0",
+ "symfony/polyfill-ctype": "^1.8"
+ },
+ "conflict": {
+ "vimeo/psalm": "<3.6.0"
+ },
+ "require-dev": {
+ "phpunit/phpunit": "^4.8.36 || ^7.5.13"
+ },
+ "type": "library",
+ "autoload": {
+ "psr-4": {
+ "Webmozart\\Assert\\": "src/"
+ }
+ },
+ "notification-url": "https://packagist.org/downloads/",
+ "license": [
+ "MIT"
+ ],
+ "authors": [
+ {
+ "name": "Bernhard Schussek",
+ "email": "bschussek@gmail.com"
+ }
+ ],
+ "description": "Assertions to validate method input/output with nice error messages.",
+ "keywords": [
+ "assert",
+ "check",
+ "validate"
+ ],
+ "time": "2019-11-24T13:36:37+00:00"
+ }
+ ],
+ "aliases": [],
+ "minimum-stability": "stable",
+ "stability-flags": [],
+ "prefer-stable": false,
+ "prefer-lowest": false,
+ "platform": {
+ "php": ">=5.4"
+ },
+ "platform-dev": []
+}
diff --git a/hdz/vendor/zbateson/stream-decorators/src/Base64Stream.php b/hdz/vendor/zbateson/stream-decorators/src/Base64Stream.php
new file mode 100644
index 0000000..2b88a2d
--- /dev/null
+++ b/hdz/vendor/zbateson/stream-decorators/src/Base64Stream.php
@@ -0,0 +1,228 @@
+stream = $stream;
+ $this->buffer = new BufferStream();
+ }
+
+ /**
+ * Returns the current position of the file read/write pointer
+ *
+ * @return int
+ */
+ public function tell()
+ {
+ return $this->position;
+ }
+
+ /**
+ * Returns null, getSize isn't supported
+ *
+ * @return null
+ */
+ public function getSize()
+ {
+ return null;
+ }
+
+ /**
+ * Not implemented (yet).
+ *
+ * Seek position can be calculated.
+ *
+ * @param int $offset
+ * @param int $whence
+ * @throws RuntimeException
+ */
+ public function seek($offset, $whence = SEEK_SET)
+ {
+ throw new RuntimeException('Cannot seek a Base64Stream');
+ }
+
+ /**
+ * Overridden to return false
+ *
+ * @return boolean
+ */
+ public function isSeekable()
+ {
+ return false;
+ }
+
+ /**
+ * Returns true if the end of stream has been reached.
+ *
+ * @return boolean
+ */
+ public function eof()
+ {
+ return ($this->buffer->eof() && $this->stream->eof());
+ }
+
+ /**
+ * Fills the internal byte buffer after reading and decoding data from the
+ * underlying stream.
+ *
+ * Note that it's expected the underlying stream will only contain valid
+ * base64 characters (normally the stream should be wrapped in a
+ * PregReplaceFilterStream to filter out non-base64 characters).
+ *
+ * @param int $length
+ */
+ private function fillBuffer($length)
+ {
+ $fill = 8192;
+ while ($this->buffer->getSize() < $length) {
+ $read = $this->stream->read($fill);
+ if ($read === false || $read === '') {
+ break;
+ }
+ $this->buffer->write(base64_decode($read));
+ }
+ }
+
+ /**
+ * Attempts to read $length bytes after decoding them, and returns them.
+ *
+ * Note that reading and writing to the same stream may result in wrongly
+ * encoded data and is not supported.
+ *
+ * @param int $length
+ * @return string
+ */
+ public function read($length)
+ {
+ // let Guzzle decide what to do.
+ if ($length <= 0 || $this->eof()) {
+ return $this->stream->read($length);
+ }
+ $this->fillBuffer($length);
+ $ret = $this->buffer->read($length);
+ $this->position += strlen($ret);
+ return $ret;
+ }
+
+ /**
+ * Writes the passed string to the underlying stream after encoding it to
+ * base64.
+ *
+ * Base64Stream::close or detach must be called. Failing to do so may
+ * result in 1-2 bytes missing from the end of the stream if there's a
+ * remainder. Note that the default Stream destructor calls close as well.
+ *
+ * Note that reading and writing to the same stream may result in wrongly
+ * encoded data and is not supported.
+ *
+ * @param string $string
+ * @return int the number of bytes written
+ */
+ public function write($string)
+ {
+ $bytes = $this->remainder . $string;
+ $len = strlen($bytes);
+ if (($len % 3) !== 0) {
+ $this->remainder = substr($bytes, -($len % 3));
+ $bytes = substr($bytes, 0, $len - ($len % 3));
+ } else {
+ $this->remainder = '';
+ }
+ $this->stream->write(base64_encode($bytes));
+ $written = strlen($string);
+ $this->position += $len;
+ return $written;
+ }
+
+ /**
+ * Writes out any remaining bytes at the end of the stream and closes.
+ */
+ private function beforeClose()
+ {
+ if ($this->isWritable() && $this->remainder !== '') {
+ $this->stream->write(base64_encode($this->remainder));
+ $this->remainder = '';
+ }
+ }
+
+ /**
+ * Closes the underlying stream after writing out any remaining bytes
+ * needing to be encoded.
+ */
+ public function close()
+ {
+ $this->beforeClose();
+ $this->stream->close();
+ }
+
+ /**
+ * Detaches the underlying stream after writing out any remaining bytes
+ * needing to be encoded.
+ */
+ public function detach()
+ {
+ $this->beforeClose();
+ $this->stream->detach();
+ }
+}
diff --git a/hdz/vendor/zbateson/stream-decorators/src/CharsetStream.php b/hdz/vendor/zbateson/stream-decorators/src/CharsetStream.php
new file mode 100644
index 0000000..d8315c1
--- /dev/null
+++ b/hdz/vendor/zbateson/stream-decorators/src/CharsetStream.php
@@ -0,0 +1,182 @@
+stream = $stream;
+ $this->converter = new MbWrapper();
+ $this->streamCharset = $streamCharset;
+ $this->stringCharset = $stringCharset;
+ }
+
+ /**
+ * Overridden to return the position in the target encoding.
+ *
+ * @return int
+ */
+ public function tell()
+ {
+ return $this->position;
+ }
+
+ /**
+ * Returns null, getSize isn't supported
+ *
+ * @return null
+ */
+ public function getSize()
+ {
+ return null;
+ }
+
+ /**
+ * Not supported.
+ *
+ * @param int $offset
+ * @param int $whence
+ * @throws RuntimeException
+ */
+ public function seek($offset, $whence = SEEK_SET)
+ {
+ throw new RuntimeException('Cannot seek a CharsetStream');
+ }
+
+ /**
+ * Overridden to return false
+ *
+ * @return boolean
+ */
+ public function isSeekable()
+ {
+ return false;
+ }
+
+ /**
+ * Reads a minimum of $length characters from the underlying stream in its
+ * encoding into $this->buffer.
+ *
+ * Aligning to 4 bytes seemed to solve an issue reading from UTF-16LE
+ * streams and pass testReadUtf16LeToEof, although the buffered string
+ * should've solved that on its own.
+ *
+ * @param int $length
+ */
+ private function readRawCharsIntoBuffer($length)
+ {
+ $n = ceil(($length + 32) / 4.0) * 4;
+ while ($this->bufferLength < $n) {
+ $raw = $this->stream->read($n + 512);
+ if ($raw === false || $raw === '') {
+ return;
+ }
+ $this->buffer .= $raw;
+ $this->bufferLength = $this->converter->getLength($this->buffer, $this->streamCharset);
+ }
+ }
+
+ /**
+ * Returns true if the end of stream has been reached.
+ *
+ * @return boolean
+ */
+ public function eof()
+ {
+ return ($this->bufferLength === 0 && $this->stream->eof());
+ }
+
+ /**
+ * Reads up to $length decoded chars from the underlying stream and returns
+ * them after converting to the target string charset.
+ *
+ * @param int $length
+ * @return string
+ */
+ public function read($length)
+ {
+ // let Guzzle decide what to do.
+ if ($length <= 0 || $this->eof()) {
+ return $this->stream->read($length);
+ }
+ $this->readRawCharsIntoBuffer($length);
+ $numChars = min([$this->bufferLength, $length]);
+ $chars = $this->converter->getSubstr($this->buffer, $this->streamCharset, 0, $numChars);
+
+ $this->position += $numChars;
+ $this->buffer = $this->converter->getSubstr($this->buffer, $this->streamCharset, $numChars);
+ $this->bufferLength = $this->bufferLength - $numChars;
+
+ return $this->converter->convert($chars, $this->streamCharset, $this->stringCharset);
+ }
+
+ /**
+ * Writes the passed string to the underlying stream after converting it to
+ * the target stream encoding.
+ *
+ * @param string $string
+ * @return int the number of bytes written
+ */
+ public function write($string)
+ {
+ $converted = $this->converter->convert($string, $this->stringCharset, $this->streamCharset);
+ $written = $this->converter->getLength($converted, $this->streamCharset);
+ $this->position += $written;
+ return $this->stream->write($converted);
+ }
+}
diff --git a/hdz/vendor/zbateson/stream-decorators/src/ChunkSplitStream.php b/hdz/vendor/zbateson/stream-decorators/src/ChunkSplitStream.php
new file mode 100644
index 0000000..9fc37e7
--- /dev/null
+++ b/hdz/vendor/zbateson/stream-decorators/src/ChunkSplitStream.php
@@ -0,0 +1,123 @@
+stream = $stream;
+ $this->lineLength = $lineLength;
+ $this->lineEnding = $lineEnding;
+ $this->lineEndingLength = strlen($this->lineEnding);
+ }
+
+ /**
+ * Inserts the line ending character after each line length characters in
+ * the passed string, making sure previously written bytes are taken into
+ * account.
+ *
+ * @param string $string
+ * @return string
+ */
+ private function getChunkedString($string)
+ {
+ $firstLine = '';
+ if ($this->tell() !== 0) {
+ $next = $this->lineLength - ($this->position % ($this->lineLength + $this->lineEndingLength));
+ if (strlen($string) > $next) {
+ $firstLine = substr($string, 0, $next) . $this->lineEnding;
+ $string = substr($string, $next);
+ }
+ }
+ // chunk_split always ends with the passed line ending
+ $chunked = $firstLine . chunk_split($string, $this->lineLength, $this->lineEnding);
+ return substr($chunked, 0, strlen($chunked) - $this->lineEndingLength);
+ }
+
+ /**
+ * Writes the passed string to the underlying stream, ensuring line endings
+ * are inserted every "line length" characters in the string.
+ *
+ * @param string $string
+ * @return number of bytes written
+ */
+ public function write($string)
+ {
+ $chunked = $this->getChunkedString($string);
+ $this->position += strlen($chunked);
+ return $this->stream->write($chunked);
+ }
+
+ /**
+ * Inserts a final line ending character.
+ */
+ private function beforeClose()
+ {
+ if ($this->position !== 0) {
+ $this->stream->write($this->lineEnding);
+ }
+ }
+
+ /**
+ * Closes the stream after ensuring a final line ending character is
+ * inserted.
+ */
+ public function close()
+ {
+ $this->beforeClose();
+ $this->stream->close();
+ }
+
+ /**
+ * Detaches the stream after ensuring a final line ending character is
+ * inserted.
+ */
+ public function detach()
+ {
+ $this->beforeClose();
+ $this->stream->detach();
+ }
+}
diff --git a/hdz/vendor/zbateson/stream-decorators/src/NonClosingStream.php b/hdz/vendor/zbateson/stream-decorators/src/NonClosingStream.php
new file mode 100644
index 0000000..cf45f42
--- /dev/null
+++ b/hdz/vendor/zbateson/stream-decorators/src/NonClosingStream.php
@@ -0,0 +1,57 @@
+close();
+ * rewind($f); // error, $f is a closed resource
+ * ```
+ *
+ * Instead, this would work:
+ *
+ * ```
+ * $stream = Psr7\stream_for(fopen('php://temp', 'r+'));
+ * $test = new NonClosingStream($stream);
+ * // work
+ * $test->close();
+ * $stream->rewind(); // works
+ * ```
+ *
+ * @author Zaahid Bateson
+ */
+class NonClosingStream implements StreamInterface
+{
+ use StreamDecoratorTrait;
+
+ /**
+ * Overridden to detach the underlying stream without closing it.
+ */
+ public function close()
+ {
+ $this->stream = null;
+ }
+
+ /**
+ * Overridden to detach the underlying stream without closing it.
+ */
+ public function detach()
+ {
+ $this->stream = null;
+ }
+}
diff --git a/hdz/vendor/zbateson/stream-decorators/src/PregReplaceFilterStream.php b/hdz/vendor/zbateson/stream-decorators/src/PregReplaceFilterStream.php
new file mode 100644
index 0000000..fa6c962
--- /dev/null
+++ b/hdz/vendor/zbateson/stream-decorators/src/PregReplaceFilterStream.php
@@ -0,0 +1,111 @@
+stream = $stream;
+ $this->pattern = $pattern;
+ $this->replacement = $replacement;
+ $this->buffer = new BufferStream();
+ }
+
+ /**
+ * Returns true if the end of stream has been reached.
+ *
+ * @return boolean
+ */
+ public function eof()
+ {
+ return ($this->buffer->eof() && $this->stream->eof());
+ }
+
+ /**
+ * Not supported by PregReplaceFilterStream
+ *
+ * @param int $offset
+ * @param int $whence
+ * @throws RuntimeException
+ */
+ public function seek($offset, $whence = SEEK_SET)
+ {
+ throw new RuntimeException('Cannot seek a PregReplaceFilterStream');
+ }
+
+ /**
+ * Overridden to return false
+ *
+ * @return boolean
+ */
+ public function isSeekable()
+ {
+ return false;
+ }
+
+ /**
+ * Fills the BufferStream with at least 8192 characters of input for future
+ * read operations.
+ *
+ * @param int $length
+ */
+ private function fillBuffer($length)
+ {
+ $fill = intval(max([$length, 8192]));
+ while ($this->buffer->getSize() < $length) {
+ $read = $this->stream->read($fill);
+ if ($read === false || $read === '') {
+ break;
+ }
+ $this->buffer->write(preg_replace($this->pattern, $this->replacement, $read));
+ }
+ }
+
+ /**
+ * Reads from the underlying stream, filters it and returns up to $length
+ * bytes.
+ *
+ * @param int $length
+ * @return string
+ */
+ public function read($length)
+ {
+ $this->fillBuffer($length);
+ return $this->buffer->read($length);
+ }
+}
diff --git a/hdz/vendor/zbateson/stream-decorators/src/QuotedPrintableStream.php b/hdz/vendor/zbateson/stream-decorators/src/QuotedPrintableStream.php
new file mode 100644
index 0000000..ae38763
--- /dev/null
+++ b/hdz/vendor/zbateson/stream-decorators/src/QuotedPrintableStream.php
@@ -0,0 +1,230 @@
+position;
+ }
+
+ /**
+ * Returns null, getSize isn't supported
+ *
+ * @return null
+ */
+ public function getSize()
+ {
+ return null;
+ }
+
+ /**
+ * Not supported.
+ *
+ * @param int $offset
+ * @param int $whence
+ * @throws RuntimeException
+ */
+ public function seek($offset, $whence = SEEK_SET)
+ {
+ throw new RuntimeException('Cannot seek a QuotedPrintableStream');
+ }
+
+ /**
+ * Overridden to return false
+ *
+ * @return boolean
+ */
+ public function isSeekable()
+ {
+ return false;
+ }
+
+ /**
+ * Reads $length chars from the underlying stream, prepending the past $pre
+ * to it first.
+ *
+ * If the characters read (including the prepended $pre) contain invalid
+ * quoted-printable characters, the underlying stream is rewound by the
+ * total number of characters ($length + strlen($pre)).
+ *
+ * The quoted-printable encoded characters are returned. If the characters
+ * read are invalid, '3D' is returned indicating an '=' character.
+ *
+ * @param int $length
+ * @param string $pre
+ * @return string
+ */
+ private function readEncodedChars($length, $pre = '')
+ {
+ $str = $pre . $this->stream->read($length);
+ $len = strlen($str);
+ if ($len > 0 && !preg_match('/^[0-9a-f]{2}$|^[\r\n]{1,2}.?$/is', $str) && $this->stream->isSeekable()) {
+ $this->stream->seek(-$len, SEEK_CUR);
+ return '3D'; // '=' character
+ }
+ return $str;
+ }
+
+ /**
+ * Decodes the passed $block of text.
+ *
+ * If the last or before last character is an '=' char, indicating the
+ * beginning of a quoted-printable encoded char, 1 or 2 additional bytes are
+ * read from the underlying stream respectively.
+ *
+ * The decoded string is returned.
+ *
+ * @param string $block
+ * @return string
+ */
+ private function decodeBlock($block)
+ {
+ if (substr($block, -1) === '=') {
+ $block .= $this->readEncodedChars(2);
+ } elseif (substr($block, -2, 1) === '=') {
+ $first = substr($block, -1);
+ $block = substr($block, 0, -1);
+ $block .= $this->readEncodedChars(1, $first);
+ }
+ return quoted_printable_decode($block);
+ }
+
+ /**
+ * Reads up to $length characters, appends them to the passed $str string,
+ * and returns the total number of characters read.
+ *
+ * -1 is returned if there are no more bytes to read.
+ *
+ * @param int $length
+ * @param string $append
+ * @return int
+ */
+ private function readRawDecodeAndAppend($length, &$str)
+ {
+ $block = $this->stream->read($length);
+ if ($block === false || $block === '') {
+ return -1;
+ }
+ $decoded = $this->decodeBlock($block);
+ $count = strlen($decoded);
+ $str .= $decoded;
+ return $count;
+ }
+
+ /**
+ * Reads up to $length decoded bytes from the underlying quoted-printable
+ * encoded stream and returns them.
+ *
+ * @param int $length
+ * @return string
+ */
+ public function read($length)
+ {
+ // let Guzzle decide what to do.
+ if ($length <= 0 || $this->eof()) {
+ return $this->stream->read($length);
+ }
+ $count = 0;
+ $bytes = '';
+ while ($count < $length) {
+ $nRead = $this->readRawDecodeAndAppend($length - $count, $bytes);
+ if ($nRead === -1) {
+ break;
+ }
+ $this->position += $nRead;
+ $count += $nRead;
+ }
+ return $bytes;
+ }
+
+ /**
+ * Writes the passed string to the underlying stream after encoding it as
+ * quoted-printable.
+ *
+ * Note that reading and writing to the same stream without rewinding is not
+ * supported.
+ *
+ * @param string $string
+ * @return int the number of bytes written
+ */
+ public function write($string)
+ {
+ $encodedLine = quoted_printable_encode($this->lastLine);
+ $lineAndString = rtrim(quoted_printable_encode($this->lastLine . $string), "\r\n");
+ $write = substr($lineAndString, strlen($encodedLine));
+ $this->stream->write($write);
+ $written = strlen($string);
+ $this->position += $written;
+
+ $lpos = strrpos($lineAndString, "\n");
+ $lastLine = $lineAndString;
+ if ($lpos !== false) {
+ $lastLine = substr($lineAndString, $lpos + 1);
+ }
+ $this->lastLine = quoted_printable_decode($lastLine);
+ return $written;
+ }
+
+ /**
+ * Writes out a final CRLF if the current line isn't empty.
+ */
+ private function beforeClose()
+ {
+ if ($this->isWritable() && $this->lastLine !== '') {
+ $this->stream->write("\r\n");
+ $this->lastLine = '';
+ }
+ }
+
+ /**
+ * Closes the underlying stream and writes a final CRLF if the current line
+ * isn't empty.
+ */
+ public function close()
+ {
+ $this->beforeClose();
+ $this->stream->close();
+ }
+
+ /**
+ * Closes the underlying stream and writes a final CRLF if the current line
+ * isn't empty.
+ */
+ public function detach()
+ {
+ $this->beforeClose();
+ $this->stream->detach();
+ }
+}
diff --git a/hdz/vendor/zbateson/stream-decorators/src/SeekingLimitStream.php b/hdz/vendor/zbateson/stream-decorators/src/SeekingLimitStream.php
new file mode 100644
index 0000000..08da149
--- /dev/null
+++ b/hdz/vendor/zbateson/stream-decorators/src/SeekingLimitStream.php
@@ -0,0 +1,208 @@
+stream = $stream;
+ $this->setLimit($limit);
+ $this->setOffset($offset);
+ }
+
+ /**
+ * Returns the current relative read position of this stream subset.
+ *
+ * @return int
+ */
+ public function tell()
+ {
+ return $this->position;
+ }
+
+ /**
+ * Returns the size of the limited subset of data, or null if the wrapped
+ * stream returns null for getSize.
+ *
+ * @return int|null
+ */
+ public function getSize()
+ {
+ $size = $this->stream->getSize();
+ if ($size === null) {
+ // this shouldn't happen on a seekable stream I don't think...
+ $pos = $this->stream->tell();
+ $this->stream->seek(0, SEEK_END);
+ $size = $this->stream->tell();
+ $this->stream->seek($pos);
+ }
+ if ($this->limit === -1) {
+ return $size - $this->offset;
+ } else {
+ return min([$this->limit, $size - $this->offset]);
+ }
+ }
+
+ /**
+ * Returns true if the current read position is at the end of the limited
+ * stream
+ *
+ * @return boolean
+ */
+ public function eof()
+ {
+ $size = $this->limit;
+ if ($size === -1) {
+ $size = $this->getSize();
+ }
+ return ($this->position >= $size);
+ }
+
+ /**
+ * Ensures the seek position specified is within the stream's bounds, and
+ * sets the internal position pointer (doesn't actually seek).
+ *
+ * @param int $pos
+ */
+ private function doSeek($pos)
+ {
+ if ($this->limit !== -1) {
+ $pos = min([$pos, $this->limit]);
+ }
+ $this->position = max([0, $pos]);
+ }
+
+ /**
+ * Seeks to the passed position within the confines of the limited stream's
+ * bounds.
+ *
+ * For SeekingLimitStream, no actual seek is performed on the underlying
+ * wrapped stream. Instead, an internal pointer is set, and the stream is
+ * 'seeked' on read operations
+ *
+ * @param int $offset
+ * @param int $whence
+ */
+ public function seek($offset, $whence = SEEK_SET)
+ {
+ $pos = $offset;
+ switch ($whence) {
+ case SEEK_CUR:
+ $pos = $this->position + $offset;
+ break;
+ case SEEK_END:
+ $pos = $this->limit + $offset;
+ break;
+ default:
+ break;
+ }
+ $this->doSeek($pos);
+ }
+
+ /**
+ * Sets the offset to start reading from the wrapped stream.
+ *
+ * @param int $offset
+ * @throws \RuntimeException if the stream cannot be seeked.
+ */
+ public function setOffset($offset)
+ {
+ $this->offset = $offset;
+ $this->position = 0;
+ }
+
+ /**
+ * Sets the length of the stream to the passed $limit.
+ *
+ * @param int $limit
+ */
+ public function setLimit($limit)
+ {
+ $this->limit = $limit;
+ }
+
+ /**
+ * Seeks to the current position and reads up to $length bytes, or less if
+ * it would result in reading past $this->limit
+ *
+ * @param int $length
+ * @return string
+ */
+ public function seekAndRead($length)
+ {
+ $this->stream->seek($this->offset + $this->position);
+ if ($this->limit !== -1) {
+ $length = min($length, $this->limit - $this->position);
+ if ($length <= 0) {
+ return '';
+ }
+ }
+ return $this->stream->read($length);
+ }
+
+ /**
+ * Reads from the underlying stream after seeking to the position within the
+ * bounds set for this limited stream. After reading, the wrapped stream is
+ * 'seeked' back to its position prior to the call to read().
+ *
+ * @param int $length
+ * @return string
+ */
+ public function read($length)
+ {
+ $pos = $this->stream->tell();
+ $ret = $this->seekAndRead($length);
+ $this->position += strlen($ret);
+ $this->stream->seek($pos);
+ if ($this->limit !== -1 && $this->position > $this->limit) {
+ $ret = substr($ret, 0, -($this->position - $this->limit));
+ $this->position = $this->limit;
+ }
+ return $ret;
+ }
+}
diff --git a/hdz/vendor/zbateson/stream-decorators/src/UUStream.php b/hdz/vendor/zbateson/stream-decorators/src/UUStream.php
new file mode 100644
index 0000000..f75b96d
--- /dev/null
+++ b/hdz/vendor/zbateson/stream-decorators/src/UUStream.php
@@ -0,0 +1,330 @@
+stream = $stream;
+ $this->filename = $filename;
+ $this->buffer = new BufferStream();
+ }
+
+ /**
+ * Overridden to return the position in the target encoding.
+ *
+ * @return int
+ */
+ public function tell()
+ {
+ return $this->position;
+ }
+
+ /**
+ * Returns null, getSize isn't supported
+ *
+ * @return null
+ */
+ public function getSize()
+ {
+ return null;
+ }
+
+ /**
+ * Not supported.
+ *
+ * @param int $offset
+ * @param int $whence
+ * @throws RuntimeException
+ */
+ public function seek($offset, $whence = SEEK_SET)
+ {
+ throw new RuntimeException('Cannot seek a UUStream');
+ }
+
+ /**
+ * Overridden to return false
+ *
+ * @return boolean
+ */
+ public function isSeekable()
+ {
+ return false;
+ }
+
+ /**
+ * Finds the next end-of-line character to ensure a line isn't broken up
+ * while buffering.
+ *
+ * @return string
+ */
+ private function readToEndOfLine($length)
+ {
+ $str = $this->stream->read($length);
+ if ($str === false || $str === '') {
+ return $str;
+ }
+ while (substr($str, -1) !== "\n") {
+ $chr = $this->stream->read(1);
+ if ($chr === false || $chr === '') {
+ break;
+ }
+ $str .= $chr;
+ }
+ return $str;
+ }
+
+ /**
+ * Removes invalid characters from a uuencoded string, and 'BEGIN' and 'END'
+ * line headers and footers from the passed string before returning it.
+ *
+ * @param string $str
+ * @return string
+ */
+ private function filterAndDecode($str)
+ {
+ $ret = str_replace("\r", '', $str);
+ $ret = preg_replace('/[^\x21-\xf5`\n]/', '`', $ret);
+ if ($this->position === 0) {
+ $matches = [];
+ if (preg_match('/^\s*begin\s+[^\s+]\s+([^\r\n]+)\s*$/im', $ret, $matches)) {
+ $this->filename = $matches[1];
+ }
+ $ret = preg_replace('/^\s*begin[^\r\n]+\s*$/im', '', $ret);
+ } else {
+ $ret = preg_replace('/^\s*end\s*$/im', '', $ret);
+ }
+ return convert_uudecode(trim($ret));
+ }
+
+ /**
+ * Buffers bytes into $this->buffer, removing uuencoding headers and footers
+ * and decoding them.
+ */
+ private function fillBuffer($length)
+ {
+ // 5040 = 63 * 80, seems to be good balance for buffering in benchmarks
+ // testing with a simple 'if ($length < x)' and calculating a better
+ // size reduces speeds by up to 4x
+ while ($this->buffer->getSize() < $length) {
+ $read = $this->readToEndOfLine(5040);
+ if ($read === false || $read === '') {
+ break;
+ }
+ $this->buffer->write($this->filterAndDecode($read));
+ }
+ }
+
+ /**
+ * Returns true if the end of stream has been reached.
+ *
+ * @return boolean
+ */
+ public function eof()
+ {
+ return ($this->buffer->eof() && $this->stream->eof());
+ }
+
+ /**
+ * Attempts to read $length bytes after decoding them, and returns them.
+ *
+ * @param int $length
+ * @return string
+ */
+ public function read($length)
+ {
+ // let Guzzle decide what to do.
+ if ($length <= 0 || $this->eof()) {
+ return $this->stream->read($length);
+ }
+ $this->fillBuffer($length);
+ $read = $this->buffer->read($length);
+ $this->position += strlen($read);
+ return $read;
+ }
+
+ /**
+ * Writes the 'begin' UU header line.
+ */
+ private function writeUUHeader()
+ {
+ $filename = (empty($this->filename)) ? 'null' : $this->filename;
+ $this->stream->write("begin 666 $filename");
+ }
+
+ /**
+ * Writes the '`' and 'end' UU footer lines.
+ */
+ private function writeUUFooter()
+ {
+ $this->stream->write("\r\n`\r\nend\r\n");
+ }
+
+ /**
+ * Writes the passed bytes to the underlying stream after encoding them.
+ *
+ * @param string $bytes
+ */
+ private function writeEncoded($bytes)
+ {
+ $encoded = preg_replace('/\r\n|\r|\n/', "\r\n", rtrim(convert_uuencode($bytes)));
+ // removes ending '`' line
+ $this->stream->write("\r\n" . rtrim(substr($encoded, 0, -1)));
+ }
+
+ /**
+ * Prepends any existing remainder to the passed string, then checks if the
+ * string fits into a uuencoded line, and removes and keeps any remainder
+ * from the string to write. Full lines ready for writing are returned.
+ *
+ * @param string $string
+ * @return string
+ */
+ private function handleRemainder($string)
+ {
+ $write = $this->remainder . $string;
+ $nRem = strlen($write) % 45;
+ $this->remainder = '';
+ if ($nRem !== 0) {
+ $this->remainder = substr($write, -$nRem);
+ $write = substr($write, 0, -$nRem);
+ }
+ return $write;
+ }
+
+ /**
+ * Writes the passed string to the underlying stream after encoding it.
+ *
+ * Note that reading and writing to the same stream without rewinding is not
+ * supported.
+ *
+ * Also note that some bytes may not be written until close or detach are
+ * called. This happens if written data doesn't align to a complete
+ * uuencoded 'line' of 45 bytes. In addition, the UU footer is only written
+ * when closing or detaching as well.
+ *
+ * @param string $string
+ * @return int the number of bytes written
+ */
+ public function write($string)
+ {
+ $this->isWriting = true;
+ if ($this->position === 0) {
+ $this->writeUUHeader();
+ }
+ $write = $this->handleRemainder($string);
+ if ($write !== '') {
+ $this->writeEncoded($write);
+ }
+ $written = strlen($string);
+ $this->position += $written;
+ return $written;
+ }
+
+ /**
+ * Returns the filename set in the UUEncoded header (or null)
+ *
+ * @return string
+ */
+ public function getFilename()
+ {
+ return $this->filename;
+ }
+
+ /**
+ * Sets the UUEncoded header file name written in the 'begin' header line.
+ *
+ * @param string $filename
+ */
+ public function setFilename($filename)
+ {
+ $this->filename = $filename;
+ }
+
+ /**
+ * Writes out any remaining bytes and the UU footer.
+ */
+ private function beforeClose()
+ {
+ if (!$this->isWriting) {
+ return;
+ }
+ if ($this->remainder !== '') {
+ $this->writeEncoded($this->remainder);
+ }
+ $this->remainder = '';
+ $this->isWriting = false;
+ $this->writeUUFooter();
+ }
+
+ /**
+ * Writes any remaining bytes out followed by the uu-encoded footer, then
+ * closes the stream.
+ */
+ public function close()
+ {
+ $this->beforeClose();
+ $this->stream->close();
+ }
+
+ /**
+ * Writes any remaining bytes out followed by the uu-encoded footer, then
+ * detaches the stream.
+ */
+ public function detach()
+ {
+ $this->beforeClose();
+ $this->stream->detach();
+ }
+}
diff --git a/pipe.php b/pipe.php
new file mode 100644
index 0000000..b023c17
--- /dev/null
+++ b/pipe.php
@@ -0,0 +1,12 @@
+#!/usr/bin/php -q
+systemDirectory, '/ ') . '/bootstrap.php';
+helper(['cookie','form','html','helpdesk','number','filesystem','text']);
+$mailFetcher = new \App\Controllers\MailFetcher();
+$mailFetcher->pipe();
\ No newline at end of file
diff --git a/upload/index.html b/upload/index.html
new file mode 100755
index 0000000..b702fbc
--- /dev/null
+++ b/upload/index.html
@@ -0,0 +1,11 @@
+
+
+
+ 403 Forbidden
+
+
+
+Directory access is forbidden.
+
+
+
diff --git a/upload/thumbs/index.html b/upload/thumbs/index.html
new file mode 100755
index 0000000..b702fbc
--- /dev/null
+++ b/upload/thumbs/index.html
@@ -0,0 +1,11 @@
+
+
+
+ 403 Forbidden
+
+
+
+Directory access is forbidden.
+
+
+