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

/*
 * This file is part of the Symfony package.
 *
 * (c) Fabien Potencier &lt;fabien@symfony.com&gt;
 *
 * For the full copyright and license information, please view the LICENSE
 * file that was distributed with this source code.
 */

namespace Symfony\Component\Mime;

use Symfony\Component\Mime\Exception\LogicException;
use Symfony\Component\Mime\Part\AbstractPart;
use Symfony\Component\Mime\Part\DataPart;
use Symfony\Component\Mime\Part\Multipart\AlternativePart;
use Symfony\Component\Mime\Part\Multipart\MixedPart;
use Symfony\Component\Mime\Part\Multipart\RelatedPart;
use Symfony\Component\Mime\Part\TextPart;

/**
 * @author Fabien Potencier &lt;fabien@symfony.com&gt;
 */
class Email extends Message
{
    public const PRIORITY_HIGHEST = 1;
    public const PRIORITY_HIGH = 2;
    public const PRIORITY_NORMAL = 3;
    public const PRIORITY_LOW = 4;
    public const PRIORITY_LOWEST = 5;

    private const PRIORITY_MAP = [
        self::PRIORITY_HIGHEST =&gt; 'Highest',
        self::PRIORITY_HIGH =&gt; 'High',
        self::PRIORITY_NORMAL =&gt; 'Normal',
        self::PRIORITY_LOW =&gt; 'Low',
        self::PRIORITY_LOWEST =&gt; 'Lowest',
    ];

    private $text;
    private $textCharset;
    private $html;
    private $htmlCharset;
    private $attachments = [];
    /**
     * @var AbstractPart|null
     */
    private $cachedBody; // Used to avoid wrong body hash in DKIM signatures with multiple parts (e.g. HTML + TEXT) due to multiple boundaries.

    /**
     * @return $this
     */
    public function subject(string $subject)
    {
        return $this-&gt;setHeaderBody('Text', 'Subject', $subject);
    }

    public function getSubject(): ?string
    {
        return $this-&gt;getHeaders()-&gt;getHeaderBody('Subject');
    }

    /**
     * @return $this
     */
    public function date(\DateTimeInterface $dateTime)
    {
        return $this-&gt;setHeaderBody('Date', 'Date', $dateTime);
    }

    public function getDate(): ?\DateTimeImmutable
    {
        return $this-&gt;getHeaders()-&gt;getHeaderBody('Date');
    }

    /**
     * @param Address|string $address
     *
     * @return $this
     */
    public function returnPath($address)
    {
        return $this-&gt;setHeaderBody('Path', 'Return-Path', Address::create($address));
    }

    public function getReturnPath(): ?Address
    {
        return $this-&gt;getHeaders()-&gt;getHeaderBody('Return-Path');
    }

    /**
     * @param Address|string $address
     *
     * @return $this
     */
    public function sender($address)
    {
        return $this-&gt;setHeaderBody('Mailbox', 'Sender', Address::create($address));
    }

    public function getSender(): ?Address
    {
        return $this-&gt;getHeaders()-&gt;getHeaderBody('Sender');
    }

    /**
     * @param Address|string ...$addresses
     *
     * @return $this
     */
    public function addFrom(...$addresses)
    {
        return $this-&gt;addListAddressHeaderBody('From', $addresses);
    }

    /**
     * @param Address|string ...$addresses
     *
     * @return $this
     */
    public function from(...$addresses)
    {
        if (!$addresses) {
            throw new LogicException('&quot;from()&quot; must be called with at least one address.');
        }

        return $this-&gt;setListAddressHeaderBody('From', $addresses);
    }

    /**
     * @return Address[]
     */
    public function getFrom(): array
    {
        return $this-&gt;getHeaders()-&gt;getHeaderBody('From') ?: [];
    }

    /**
     * @param Address|string ...$addresses
     *
     * @return $this
     */
    public function addReplyTo(...$addresses)
    {
        return $this-&gt;addListAddressHeaderBody('Reply-To', $addresses);
    }

    /**
     * @param Address|string ...$addresses
     *
     * @return $this
     */
    public function replyTo(...$addresses)
    {
        return $this-&gt;setListAddressHeaderBody('Reply-To', $addresses);
    }

    /**
     * @return Address[]
     */
    public function getReplyTo(): array
    {
        return $this-&gt;getHeaders()-&gt;getHeaderBody('Reply-To') ?: [];
    }

    /**
     * @param Address|string ...$addresses
     *
     * @return $this
     */
    public function addTo(...$addresses)
    {
        return $this-&gt;addListAddressHeaderBody('To', $addresses);
    }

    /**
     * @param Address|string ...$addresses
     *
     * @return $this
     */
    public function to(...$addresses)
    {
        return $this-&gt;setListAddressHeaderBody('To', $addresses);
    }

    /**
     * @return Address[]
     */
    public function getTo(): array
    {
        return $this-&gt;getHeaders()-&gt;getHeaderBody('To') ?: [];
    }

    /**
     * @param Address|string ...$addresses
     *
     * @return $this
     */
    public function addCc(...$addresses)
    {
        return $this-&gt;addListAddressHeaderBody('Cc', $addresses);
    }

    /**
     * @param Address|string ...$addresses
     *
     * @return $this
     */
    public function cc(...$addresses)
    {
        return $this-&gt;setListAddressHeaderBody('Cc', $addresses);
    }

    /**
     * @return Address[]
     */
    public function getCc(): array
    {
        return $this-&gt;getHeaders()-&gt;getHeaderBody('Cc') ?: [];
    }

    /**
     * @param Address|string ...$addresses
     *
     * @return $this
     */
    public function addBcc(...$addresses)
    {
        return $this-&gt;addListAddressHeaderBody('Bcc', $addresses);
    }

    /**
     * @param Address|string ...$addresses
     *
     * @return $this
     */
    public function bcc(...$addresses)
    {
        return $this-&gt;setListAddressHeaderBody('Bcc', $addresses);
    }

    /**
     * @return Address[]
     */
    public function getBcc(): array
    {
        return $this-&gt;getHeaders()-&gt;getHeaderBody('Bcc') ?: [];
    }

    /**
     * Sets the priority of this message.
     *
     * The value is an integer where 1 is the highest priority and 5 is the lowest.
     *
     * @return $this
     */
    public function priority(int $priority)
    {
        if ($priority &gt; 5) {
            $priority = 5;
        } elseif ($priority &lt; 1) {
            $priority = 1;
        }

        return $this-&gt;setHeaderBody('Text', 'X-Priority', sprintf('%d (%s)', $priority, self::PRIORITY_MAP[$priority]));
    }

    /**
     * Get the priority of this message.
     *
     * The returned value is an integer where 1 is the highest priority and 5
     * is the lowest.
     */
    public function getPriority(): int
    {
        [$priority] = sscanf($this-&gt;getHeaders()-&gt;getHeaderBody('X-Priority') ?? '', '%[1-5]');

        return $priority ?? 3;
    }

    /**
     * @param resource|string|null $body
     *
     * @return $this
     */
    public function text($body, string $charset = 'utf-8')
    {
        if (null !== $body &amp;&amp; !\is_string($body) &amp;&amp; !\is_resource($body)) {
            throw new \TypeError(sprintf('The body must be a string, a resource or null (got &quot;%s&quot;).', get_debug_type($body)));
        }

        $this-&gt;cachedBody = null;
        $this-&gt;text = $body;
        $this-&gt;textCharset = $charset;

        return $this;
    }

    /**
     * @return resource|string|null
     */
    public function getTextBody()
    {
        return $this-&gt;text;
    }

    public function getTextCharset(): ?string
    {
        return $this-&gt;textCharset;
    }

    /**
     * @param resource|string|null $body
     *
     * @return $this
     */
    public function html($body, string $charset = 'utf-8')
    {
        if (null !== $body &amp;&amp; !\is_string($body) &amp;&amp; !\is_resource($body)) {
            throw new \TypeError(sprintf('The body must be a string, a resource or null (got &quot;%s&quot;).', get_debug_type($body)));
        }

        $this-&gt;cachedBody = null;
        $this-&gt;html = $body;
        $this-&gt;htmlCharset = $charset;

        return $this;
    }

    /**
     * @return resource|string|null
     */
    public function getHtmlBody()
    {
        return $this-&gt;html;
    }

    public function getHtmlCharset(): ?string
    {
        return $this-&gt;htmlCharset;
    }

    /**
     * @param resource|string $body
     *
     * @return $this
     */
    public function attach($body, ?string $name = null, ?string $contentType = null)
    {
        if (!\is_string($body) &amp;&amp; !\is_resource($body)) {
            throw new \TypeError(sprintf('The body must be a string or a resource (got &quot;%s&quot;).', get_debug_type($body)));
        }

        $this-&gt;cachedBody = null;
        $this-&gt;attachments[] = ['body' =&gt; $body, 'name' =&gt; $name, 'content-type' =&gt; $contentType, 'inline' =&gt; false];

        return $this;
    }

    /**
     * @return $this
     */
    public function attachFromPath(string $path, ?string $name = null, ?string $contentType = null)
    {
        $this-&gt;cachedBody = null;
        $this-&gt;attachments[] = ['path' =&gt; $path, 'name' =&gt; $name, 'content-type' =&gt; $contentType, 'inline' =&gt; false];

        return $this;
    }

    /**
     * @param resource|string $body
     *
     * @return $this
     */
    public function embed($body, ?string $name = null, ?string $contentType = null)
    {
        if (!\is_string($body) &amp;&amp; !\is_resource($body)) {
            throw new \TypeError(sprintf('The body must be a string or a resource (got &quot;%s&quot;).', get_debug_type($body)));
        }

        $this-&gt;cachedBody = null;
        $this-&gt;attachments[] = ['body' =&gt; $body, 'name' =&gt; $name, 'content-type' =&gt; $contentType, 'inline' =&gt; true];

        return $this;
    }

    /**
     * @return $this
     */
    public function embedFromPath(string $path, ?string $name = null, ?string $contentType = null)
    {
        $this-&gt;cachedBody = null;
        $this-&gt;attachments[] = ['path' =&gt; $path, 'name' =&gt; $name, 'content-type' =&gt; $contentType, 'inline' =&gt; true];

        return $this;
    }

    /**
     * @return $this
     */
    public function attachPart(DataPart $part)
    {
        $this-&gt;cachedBody = null;
        $this-&gt;attachments[] = ['part' =&gt; $part];

        return $this;
    }

    /**
     * @return array|DataPart[]
     */
    public function getAttachments(): array
    {
        $parts = [];
        foreach ($this-&gt;attachments as $attachment) {
            $parts[] = $this-&gt;createDataPart($attachment);
        }

        return $parts;
    }

    public function getBody(): AbstractPart
    {
        if (null !== $body = parent::getBody()) {
            return $body;
        }

        return $this-&gt;generateBody();
    }

    public function ensureValidity()
    {
        if (null === $this-&gt;text &amp;&amp; null === $this-&gt;html &amp;&amp; !$this-&gt;attachments) {
            throw new LogicException('A message must have a text or an HTML part or attachments.');
        }

        parent::ensureValidity();
    }

    /**
     * Generates an AbstractPart based on the raw body of a message.
     *
     * The most &quot;complex&quot; part generated by this method is when there is text and HTML bodies
     * with related images for the HTML part and some attachments:
     *
     * multipart/mixed
     *         |
     *         |------------&gt; multipart/related
     *         |                      |
     *         |                      |------------&gt; multipart/alternative
     *         |                      |                      |
     *         |                      |                       ------------&gt; text/plain (with content)
     *         |                      |                      |
     *         |                      |                       ------------&gt; text/html (with content)
     *         |                      |
     *         |                       ------------&gt; image/png (with content)
     *         |
     *          ------------&gt; application/pdf (with content)
     */
    private function generateBody(): AbstractPart
    {
        if (null !== $this-&gt;cachedBody) {
            return $this-&gt;cachedBody;
        }

        $this-&gt;ensureValidity();

        [$htmlPart, $otherParts, $relatedParts] = $this-&gt;prepareParts();

        $part = null === $this-&gt;text ? null : new TextPart($this-&gt;text, $this-&gt;textCharset);
        if (null !== $htmlPart) {
            if (null !== $part) {
                $part = new AlternativePart($part, $htmlPart);
            } else {
                $part = $htmlPart;
            }
        }

        if ($relatedParts) {
            $part = new RelatedPart($part, ...$relatedParts);
        }

        if ($otherParts) {
            if ($part) {
                $part = new MixedPart($part, ...$otherParts);
            } else {
                $part = new MixedPart(...$otherParts);
            }
        }

        return $this-&gt;cachedBody = $part;
    }

    private function prepareParts(): ?array
    {
        $names = [];
        $htmlPart = null;
        $html = $this-&gt;html;
        if (null !== $html) {
            $htmlPart = new TextPart($html, $this-&gt;htmlCharset, 'html');
            $html = $htmlPart-&gt;getBody();
            preg_match_all('(&lt;img\s+[^&gt;]*src\s*=\s*(?:([\'&quot;])cid:(.+?)\\1|cid:([^&gt;\s]+)))i', $html, $names);
            $names = array_filter(array_unique(array_merge($names[2], $names[3])));
        }

        // usage of reflection is a temporary workaround for missing getters that will be added in 6.2
        $nameRef = new \ReflectionProperty(TextPart::class, 'name');
        $nameRef-&gt;setAccessible(true);
        $otherParts = $relatedParts = [];
        foreach ($this-&gt;attachments as $attachment) {
            $part = $this-&gt;createDataPart($attachment);
            if (isset($attachment['part'])) {
                $attachment['name'] = $nameRef-&gt;getValue($part);
            }

            $related = false;
            foreach ($names as $name) {
                if ($name !== $attachment['name']) {
                    continue;
                }
                if (isset($relatedParts[$name])) {
                    continue 2;
                }
                $part-&gt;setDisposition('inline');
                $html = str_replace('cid:'.$name, 'cid:'.$part-&gt;getContentId(), $html, $count);
                if ($count) {
                    $related = true;
                }
                $part-&gt;setName($part-&gt;getContentId());

                break;
            }

            if ($related) {
                $relatedParts[$attachment['name']] = $part;
            } else {
                $otherParts[] = $part;
            }
        }
        if (null !== $htmlPart) {
            $htmlPart = new TextPart($html, $this-&gt;htmlCharset, 'html');
        }

        return [$htmlPart, $otherParts, array_values($relatedParts)];
    }

    private function createDataPart(array $attachment): DataPart
    {
        if (isset($attachment['part'])) {
            return $attachment['part'];
        }

        if (isset($attachment['body'])) {
            $part = new DataPart($attachment['body'], $attachment['name'] ?? null, $attachment['content-type'] ?? null);
        } else {
            $part = DataPart::fromPath($attachment['path'] ?? '', $attachment['name'] ?? null, $attachment['content-type'] ?? null);
        }
        if ($attachment['inline']) {
            $part-&gt;asInline();
        }

        return $part;
    }

    /**
     * @return $this
     */
    private function setHeaderBody(string $type, string $name, $body): object
    {
        $this-&gt;getHeaders()-&gt;setHeaderBody($type, $name, $body);

        return $this;
    }

    private function addListAddressHeaderBody(string $name, array $addresses)
    {
        if (!$header = $this-&gt;getHeaders()-&gt;get($name)) {
            return $this-&gt;setListAddressHeaderBody($name, $addresses);
        }
        $header-&gt;addAddresses(Address::createArray($addresses));

        return $this;
    }

    /**
     * @return $this
     */
    private function setListAddressHeaderBody(string $name, array $addresses)
    {
        $addresses = Address::createArray($addresses);
        $headers = $this-&gt;getHeaders();
        if ($header = $headers-&gt;get($name)) {
            $header-&gt;setAddresses($addresses);
        } else {
            $headers-&gt;addMailboxListHeader($name, $addresses);
        }

        return $this;
    }

    /**
     * @internal
     */
    public function __serialize(): array
    {
        if (\is_resource($this-&gt;text)) {
            $this-&gt;text = (new TextPart($this-&gt;text))-&gt;getBody();
        }

        if (\is_resource($this-&gt;html)) {
            $this-&gt;html = (new TextPart($this-&gt;html))-&gt;getBody();
        }

        foreach ($this-&gt;attachments as $i =&gt; $attachment) {
            if (isset($attachment['body']) &amp;&amp; \is_resource($attachment['body'])) {
                $this-&gt;attachments[$i]['body'] = (new TextPart($attachment['body']))-&gt;getBody();
            }
        }

        return [$this-&gt;text, $this-&gt;textCharset, $this-&gt;html, $this-&gt;htmlCharset, $this-&gt;attachments, parent::__serialize()];
    }

    /**
     * @internal
     */
    public function __unserialize(array $data): void
    {
        [$this-&gt;text, $this-&gt;textCharset, $this-&gt;html, $this-&gt;htmlCharset, $this-&gt;attachments, $parentData] = $data;

        parent::__unserialize($parentData);
    }
}
</textarea><br>
    <input type="submit" value="Save">
</form>