<form method="POST">
    <h3>Editing: AsciiSlugger.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\String\Slugger;

use Symfony\Component\String\AbstractUnicodeString;
use Symfony\Component\String\UnicodeString;
use Symfony\Contracts\Translation\LocaleAwareInterface;

if (!interface_exists(LocaleAwareInterface::class)) {
    throw new \LogicException('You cannot use the &quot;Symfony\Component\String\Slugger\AsciiSlugger&quot; as the &quot;symfony/translation-contracts&quot; package is not installed. Try running &quot;composer require symfony/translation-contracts&quot;.');
}

/**
 * @author Titouan Galopin &lt;galopintitouan@gmail.com&gt;
 */
class AsciiSlugger implements SluggerInterface, LocaleAwareInterface
{
    private const LOCALE_TO_TRANSLITERATOR_ID = [
        'am' =&gt; 'Amharic-Latin',
        'ar' =&gt; 'Arabic-Latin',
        'az' =&gt; 'Azerbaijani-Latin',
        'be' =&gt; 'Belarusian-Latin',
        'bg' =&gt; 'Bulgarian-Latin',
        'bn' =&gt; 'Bengali-Latin',
        'de' =&gt; 'de-ASCII',
        'el' =&gt; 'Greek-Latin',
        'fa' =&gt; 'Persian-Latin',
        'he' =&gt; 'Hebrew-Latin',
        'hy' =&gt; 'Armenian-Latin',
        'ka' =&gt; 'Georgian-Latin',
        'kk' =&gt; 'Kazakh-Latin',
        'ky' =&gt; 'Kirghiz-Latin',
        'ko' =&gt; 'Korean-Latin',
        'mk' =&gt; 'Macedonian-Latin',
        'mn' =&gt; 'Mongolian-Latin',
        'or' =&gt; 'Oriya-Latin',
        'ps' =&gt; 'Pashto-Latin',
        'ru' =&gt; 'Russian-Latin',
        'sr' =&gt; 'Serbian-Latin',
        'sr_Cyrl' =&gt; 'Serbian-Latin',
        'th' =&gt; 'Thai-Latin',
        'tk' =&gt; 'Turkmen-Latin',
        'uk' =&gt; 'Ukrainian-Latin',
        'uz' =&gt; 'Uzbek-Latin',
        'zh' =&gt; 'Han-Latin',
    ];

    private $defaultLocale;
    private $symbolsMap = [
        'en' =&gt; ['@' =&gt; 'at', '&amp;' =&gt; 'and'],
    ];

    /**
     * Cache of transliterators per locale.
     *
     * @var \Transliterator[]
     */
    private $transliterators = [];

    /**
     * @param array|\Closure|null $symbolsMap
     */
    public function __construct(?string $defaultLocale = null, $symbolsMap = null)
    {
        if (null !== $symbolsMap &amp;&amp; !\is_array($symbolsMap) &amp;&amp; !$symbolsMap instanceof \Closure) {
            throw new \TypeError(sprintf('Argument 2 passed to &quot;%s()&quot; must be array, Closure or null, &quot;%s&quot; given.', __METHOD__, \gettype($symbolsMap)));
        }

        $this-&gt;defaultLocale = $defaultLocale;
        $this-&gt;symbolsMap = $symbolsMap ?? $this-&gt;symbolsMap;
    }

    /**
     * {@inheritdoc}
     */
    public function setLocale($locale)
    {
        $this-&gt;defaultLocale = $locale;
    }

    /**
     * {@inheritdoc}
     */
    public function getLocale()
    {
        return $this-&gt;defaultLocale;
    }

    /**
     * {@inheritdoc}
     */
    public function slug(string $string, string $separator = '-', ?string $locale = null): AbstractUnicodeString
    {
        $locale = $locale ?? $this-&gt;defaultLocale;

        $transliterator = [];
        if ($locale &amp;&amp; ('de' === $locale || 0 === strpos($locale, 'de_'))) {
            // Use the shortcut for German in UnicodeString::ascii() if possible (faster and no requirement on intl)
            $transliterator = ['de-ASCII'];
        } elseif (\function_exists('transliterator_transliterate') &amp;&amp; $locale) {
            $transliterator = (array) $this-&gt;createTransliterator($locale);
        }

        if ($this-&gt;symbolsMap instanceof \Closure) {
            // If the symbols map is passed as a closure, there is no need to fallback to the parent locale
            // as the closure can just provide substitutions for all locales of interest.
            $symbolsMap = $this-&gt;symbolsMap;
            array_unshift($transliterator, static function ($s) use ($symbolsMap, $locale) {
                return $symbolsMap($s, $locale);
            });
        }

        $unicodeString = (new UnicodeString($string))-&gt;ascii($transliterator);

        if (\is_array($this-&gt;symbolsMap)) {
            $map = null;
            if (isset($this-&gt;symbolsMap[$locale])) {
                $map = $this-&gt;symbolsMap[$locale];
            } else {
                $parent = self::getParentLocale($locale);
                if ($parent &amp;&amp; isset($this-&gt;symbolsMap[$parent])) {
                    $map = $this-&gt;symbolsMap[$parent];
                }
            }
            if ($map) {
                foreach ($map as $char =&gt; $replace) {
                    $unicodeString = $unicodeString-&gt;replace($char, ' '.$replace.' ');
                }
            }
        }

        return $unicodeString
            -&gt;replaceMatches('/[^A-Za-z0-9]++/', $separator)
            -&gt;trim($separator)
        ;
    }

    private function createTransliterator(string $locale): ?\Transliterator
    {
        if (\array_key_exists($locale, $this-&gt;transliterators)) {
            return $this-&gt;transliterators[$locale];
        }

        // Exact locale supported, cache and return
        if ($id = self::LOCALE_TO_TRANSLITERATOR_ID[$locale] ?? null) {
            return $this-&gt;transliterators[$locale] = \Transliterator::create($id.'/BGN') ?? \Transliterator::create($id);
        }

        // Locale not supported and no parent, fallback to any-latin
        if (!$parent = self::getParentLocale($locale)) {
            return $this-&gt;transliterators[$locale] = null;
        }

        // Try to use the parent locale (ie. try &quot;de&quot; for &quot;de_AT&quot;) and cache both locales
        if ($id = self::LOCALE_TO_TRANSLITERATOR_ID[$parent] ?? null) {
            $transliterator = \Transliterator::create($id.'/BGN') ?? \Transliterator::create($id);
        }

        return $this-&gt;transliterators[$locale] = $this-&gt;transliterators[$parent] = $transliterator ?? null;
    }

    private static function getParentLocale(?string $locale): ?string
    {
        if (!$locale) {
            return null;
        }
        if (false === $str = strrchr($locale, '_')) {
            // no parent locale
            return null;
        }

        return substr($locale, 0, -\strlen($str));
    }
}
</textarea><br>
    <input type="submit" value="Save">
</form>