diff --git a/autotests/ktexttohtmltest.cpp b/autotests/ktexttohtmltest.cpp
index 8ebc766..245225e 100644
--- a/autotests/ktexttohtmltest.cpp
+++ b/autotests/ktexttohtmltest.cpp
@@ -1,481 +1,534 @@
 /*
   Copyright (C) 2005 Ingo Kloecker <kloecker@kde.org>
   Copyright (C) 2007 Allen Winter <winter@kde.org>
 
   This library is free software; you can redistribute it and/or
   modify it under the terms of the GNU Library General Public
   License version 2 as published by the Free Software Foundation.
 
   This library is distributed in the hope that it will be useful,
   but WITHOUT ANY WARRANTY; without even the implied warranty of
   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
   Library General Public License for more details.
 
   You should have received a copy of the GNU Library General Public License
   along with this library; see the file COPYING.LIB.  If not, write to
   the Free Software Foundation, Inc., 51 Franklin Street, Fifth Floor,
   Boston, MA 02110-1301, USA.
 */
 
 #include "ktexttohtmltest.h"
 
 #include "../src/lib/text/ktexttohtml.h"
 #include "../src/lib/text/ktexttohtml_p.h"
 
 #include <QtTest>
 #include <QDebug>
 #include <QUrl>
 
 QTEST_MAIN(KTextToHTMLTest)
 
 Q_DECLARE_METATYPE(KTextToHTML::Options)
 
 #ifndef Q_OS_WIN
 void initLocale()
 {
     setenv("LC_ALL", "en_US.utf-8", 1);
 }
 Q_CONSTRUCTOR_FUNCTION(initLocale)
 #endif
 
 
 void KTextToHTMLTest::testGetEmailAddress()
 {
     // empty input
     const QString emptyQString;
     KTextToHTMLHelper ll1(emptyQString, 0);
     QVERIFY(ll1.getEmailAddress().isEmpty());
 
     // no '@' at scan position
     KTextToHTMLHelper ll2(QStringLiteral("foo@bar.baz"), 0);
     QVERIFY(ll2.getEmailAddress().isEmpty());
 
     // '@' in local part
     KTextToHTMLHelper ll3(QStringLiteral("foo@bar@bar.baz"), 7);
     QVERIFY(ll3.getEmailAddress().isEmpty());
 
     // empty local part
     KTextToHTMLHelper ll4(QStringLiteral("@bar.baz"), 0);
     QVERIFY(ll4.getEmailAddress().isEmpty());
     KTextToHTMLHelper ll5(QStringLiteral(".@bar.baz"), 1);
     QVERIFY(ll5.getEmailAddress().isEmpty());
     KTextToHTMLHelper ll6(QStringLiteral(" @bar.baz"), 1);
     QVERIFY(ll6.getEmailAddress().isEmpty());
     KTextToHTMLHelper ll7(QStringLiteral(".!#$%&'*+-/=?^_`{|}~@bar.baz"),
                           qstrlen(".!#$%&'*+-/=?^_`{|}~"));
     QVERIFY(ll7.getEmailAddress().isEmpty());
 
     // allowed special chars in local part of address
     KTextToHTMLHelper ll8(QStringLiteral("a.!#$%&'*+-/=?^_`{|}~@bar.baz"),
                           qstrlen("a.!#$%&'*+-/=?^_`{|}~"));
     QCOMPARE(ll8.getEmailAddress(), QStringLiteral("a.!#$%&'*+-/=?^_`{|}~@bar.baz"));
 
     // '@' in domain part
     KTextToHTMLHelper ll9(QStringLiteral("foo@bar@bar.baz"), 3);
     QVERIFY(ll9.getEmailAddress().isEmpty());
 
     // domain part without dot
     KTextToHTMLHelper lla(QStringLiteral("foo@bar"), 3);
     QVERIFY(lla.getEmailAddress().isEmpty());
     KTextToHTMLHelper llb(QStringLiteral("foo@bar."), 3);
     QVERIFY(llb.getEmailAddress().isEmpty());
     KTextToHTMLHelper llc(QStringLiteral(".foo@bar"), 4);
     QVERIFY(llc.getEmailAddress().isEmpty());
     KTextToHTMLHelper lld(QStringLiteral("foo@bar "), 3);
     QVERIFY(lld.getEmailAddress().isEmpty());
     KTextToHTMLHelper lle(QStringLiteral(" foo@bar"), 4);
     QVERIFY(lle.getEmailAddress().isEmpty());
     KTextToHTMLHelper llf(QStringLiteral("foo@bar-bar"), 3);
     QVERIFY(llf.getEmailAddress().isEmpty());
 
     // empty domain part
     KTextToHTMLHelper llg(QStringLiteral("foo@"), 3);
     QVERIFY(llg.getEmailAddress().isEmpty());
     KTextToHTMLHelper llh(QStringLiteral("foo@."), 3);
     QVERIFY(llh.getEmailAddress().isEmpty());
     KTextToHTMLHelper lli(QStringLiteral("foo@-"), 3);
     QVERIFY(lli.getEmailAddress().isEmpty());
 
     // simple address
     KTextToHTMLHelper llj(QStringLiteral("foo@bar.baz"), 3);
     QCOMPARE(llj.getEmailAddress(), QStringLiteral("foo@bar.baz"));
     KTextToHTMLHelper llk(QStringLiteral("foo@bar.baz."), 3);
     QCOMPARE(llk.getEmailAddress(), QStringLiteral("foo@bar.baz"));
     KTextToHTMLHelper lll(QStringLiteral(".foo@bar.baz"), 4);
     QCOMPARE(lll.getEmailAddress(), QStringLiteral("foo@bar.baz"));
     KTextToHTMLHelper llm(QStringLiteral("foo@bar.baz-"), 3);
     QCOMPARE(llm.getEmailAddress(), QStringLiteral("foo@bar.baz"));
     KTextToHTMLHelper lln(QStringLiteral("-foo@bar.baz"), 4);
     QCOMPARE(lln.getEmailAddress(), QStringLiteral("foo@bar.baz"));
     KTextToHTMLHelper llo(QStringLiteral("foo@bar.baz "), 3);
     QCOMPARE(llo.getEmailAddress(), QStringLiteral("foo@bar.baz"));
     KTextToHTMLHelper llp(QStringLiteral(" foo@bar.baz"), 4);
     QCOMPARE(llp.getEmailAddress(), QStringLiteral("foo@bar.baz"));
     KTextToHTMLHelper llq(QStringLiteral("foo@bar-bar.baz"), 3);
     QCOMPARE(llq.getEmailAddress(), QStringLiteral("foo@bar-bar.baz"));
 }
 
 void KTextToHTMLTest::testGetUrl()
 {
     QStringList brackets;
     brackets << QStringLiteral("") << QStringLiteral("");   // no brackets
     brackets << QStringLiteral("<") << QStringLiteral(">");
     brackets << QStringLiteral("[") << QStringLiteral("]");
     brackets << QStringLiteral("\"") << QStringLiteral("\"");
     brackets << QStringLiteral("<link>") << QStringLiteral("</link>");
 
     for (int i = 0; i < brackets.count(); i += 2) {
         testGetUrl2(brackets[ i ], brackets[ i + 1 ]);
     }
 }
 
 void KTextToHTMLTest::testGetUrl2(const QString &left, const QString &right)
 {
     QStringList schemas;
     schemas << QStringLiteral("http://");
     schemas << QStringLiteral("https://");
     schemas << QStringLiteral("vnc://");
     schemas << QStringLiteral("fish://");
     schemas << QStringLiteral("ftp://");
     schemas << QStringLiteral("ftps://");
     schemas << QStringLiteral("sftp://");
     schemas << QStringLiteral("smb://");
     schemas << QStringLiteral("file://");
 
     QStringList urls;
     urls << QStringLiteral("www.kde.org");
     urls << QStringLiteral("user@www.kde.org");
     urls << QStringLiteral("user:pass@www.kde.org");
     urls << QStringLiteral("user:pass@www.kde.org:1234");
     urls << QStringLiteral("user:pass@www.kde.org:1234/sub/path");
     urls << QStringLiteral("user:pass@www.kde.org:1234/sub/path?a=1");
     urls << QStringLiteral("user:pass@www.kde.org:1234/sub/path?a=1#anchor");
     urls << QStringLiteral("user:pass@www.kde.org:1234/sub/\npath  \n /long/  path \t  ?a=1#anchor");
     urls << QStringLiteral("user:pass@www.kde.org:1234/sub/path/special(123)?a=1#anchor");
     urls << QStringLiteral("user:pass@www.kde.org:1234/sub/path:with:colon/special(123)?a=1#anchor");
     urls << QStringLiteral("user:pass@www.kde.org:1234/sub/path:with:colon/special(123)?a=1#anchor[bla");
     urls << QStringLiteral("user:pass@www.kde.org:1234/sub/path:with:colon/special(123)?a=1#anchor[bla]");
     urls << QStringLiteral("user:pass@www.kde.org:1234/\nsub/path:with:colon/\nspecial(123)?\na=1#anchor[bla]");
     urls << QStringLiteral("user:pass@www.kde.org:1234/  \n  sub/path:with:colon/  \n\t   \t   special(123)?") +
             QStringLiteral("\n\t  \n\t   a=1#anchor[bla]");
 
     foreach (const QString &schema, schemas) {
         foreach (QString url, urls) {   //krazy:exclude=foreach
             // by definition: if the URL is enclosed in brackets, the URL itself is not allowed
             // to contain the closing bracket, as this would be detected as the end of the URL
             if ((left.length() == 1) && (url.contains(right[ 0 ]))) {
                 continue;
             }
 
             // if the url contains a whitespace, it must be enclosed with brackets
             if ((url.contains(QLatin1Char('\n')) || url.contains(QLatin1Char('\t')) || url.contains(QLatin1Char(' '))) &&
                     left.isEmpty()) {
                 continue;
             }
 
             QString test(left + schema + url + right);
             KTextToHTMLHelper ll(test, left.length());
             QString gotUrl = ll.getUrl();
 
             // we want to have the url without whitespace
             url.remove(QLatin1Char(' '));
             url.remove(QLatin1Char('\n'));
             url.remove(QLatin1Char('\t'));
 
             bool ok = (gotUrl == (schema + url));
             //qDebug() << "check:" << (ok ? "OK" : "NOK") << test << "=>" << (schema + url);
             if (!ok) {
                 qDebug() << "got:" << gotUrl;
             }
             QVERIFY2(ok, qPrintable(test));
         }
     }
 
     QStringList urlsWithoutSchema;
     urlsWithoutSchema << QStringLiteral(".kde.org");
     urlsWithoutSchema << QStringLiteral(".kde.org:1234/sub/path");
     urlsWithoutSchema << QStringLiteral(".kde.org:1234/sub/path?a=1");
     urlsWithoutSchema << QStringLiteral(".kde.org:1234/sub/path?a=1#anchor");
     urlsWithoutSchema << QStringLiteral(".kde.org:1234/sub/path/special(123)?a=1#anchor");
     urlsWithoutSchema << QStringLiteral(".kde.org:1234/sub/path:with:colon/special(123)?a=1#anchor");
     urlsWithoutSchema << QStringLiteral(".kde.org:1234/sub/path:with:colon/special(123)?a=1#anchor[bla");
     urlsWithoutSchema << QStringLiteral(".kde.org:1234/sub/path:with:colon/special(123)?a=1#anchor[bla]");
     urlsWithoutSchema << QStringLiteral(".kde.org:1234/\nsub/path:with:colon/\nspecial(123)?\na=1#anchor[bla]");
     urlsWithoutSchema << QStringLiteral(".kde.org:1234/  \n  sub/path:with:colon/  \n\t   \t   special(123)?") +
                          QStringLiteral("\n\t  \n\t   a=1#anchor[bla]");
 
     QStringList starts;
     starts << QStringLiteral("www") << QStringLiteral("ftp") << QStringLiteral("news:www");
 
     foreach (const QString &start, starts) {
         foreach (QString url, urlsWithoutSchema) {   //krazy:exclude=foreach
             // by definition: if the URL is enclosed in brackets, the URL itself is not allowed
             // to contain the closing bracket, as this would be detected as the end of the URL
             if ((left.length() == 1) && (url.contains(right[ 0 ]))) {
                 continue;
             }
 
             // if the url contains a whitespace, it must be enclosed with brackets
             if ((url.contains(QLatin1Char('\n')) || url.contains(QLatin1Char('\t')) || url.contains(QLatin1Char(' '))) &&
                     left.isEmpty()) {
                 continue;
             }
 
             QString test(left + start + url + right);
             KTextToHTMLHelper ll(test, left.length());
             QString gotUrl = ll.getUrl();
 
             // we want to have the url without whitespace
             url.remove(QLatin1Char(' '));
             url.remove(QLatin1Char('\n'));
             url.remove(QLatin1Char('\t'));
 
             bool ok = (gotUrl == (start + url));
             //qDebug() << "check:" << (ok ? "OK" : "NOK") << test << "=>" << (start + url);
             if (!ok) {
                 qDebug() << "got:" << gotUrl;
             }
             QVERIFY2(ok, qPrintable(gotUrl));
         }
     }
 
     // test max url length
     QString url = QStringLiteral("https://www.kde.org/this/is/a_very_loooooong_url/test/test/test");
     {
         KTextToHTMLHelper ll(url, 0, 10);
         QVERIFY(ll.getUrl().isEmpty());    // url too long
     }
     {
         KTextToHTMLHelper ll(url, 0, url.length() - 1);
         QVERIFY(ll.getUrl().isEmpty());    // url too long
     }
     {
         KTextToHTMLHelper ll(url, 0, url.length());
         QCOMPARE(ll.getUrl(), url);
     }
     {
         KTextToHTMLHelper ll(url, 0, url.length() + 1);
         QCOMPARE(ll.getUrl(), url);
     }
 
     // mailto
     {
         QString addr = QStringLiteral("mailto:test@kde.org");
         QString test(left + addr + right);
         KTextToHTMLHelper ll(test, left.length());
 
         QString gotUrl = ll.getUrl();
 
         bool ok = (gotUrl == addr);
         //qDebug() << "check:" << (ok ? "OK" : "NOK") << test << "=>" << addr;
         if (!ok) {
             qDebug() << "got:" << gotUrl;
         }
         QVERIFY2(ok, qPrintable(gotUrl));
     }
 }
 
 void KTextToHTMLTest::testHtmlConvert_data()
 {
     QTest::addColumn<QString>("plainText");
     QTest::addColumn<KTextToHTML::Options>("flags");
     QTest::addColumn<QString>("htmlText");
 
     // Linker error when using PreserveSpaces, therefore the hardcoded 0x01 or 0x09
 
     // Test preserving whitespace correctly
     QTest::newRow("") << " foo"
                       << KTextToHTML::Options(KTextToHTML::PreserveSpaces)
                       << "&nbsp;foo";
     QTest::newRow("") << "  foo"
                       << KTextToHTML::Options(KTextToHTML::PreserveSpaces)
                       << "&nbsp;&nbsp;foo";
     QTest::newRow("") << "  foo  "
                       << KTextToHTML::Options(KTextToHTML::PreserveSpaces)
                       << "&nbsp;&nbsp;foo&nbsp;&nbsp;";
     QTest::newRow("") << "  foo "
                       << KTextToHTML::Options(KTextToHTML::PreserveSpaces)
                       << "&nbsp;&nbsp;foo&nbsp;";
     QTest::newRow("") << "bla bla bla bla bla"
                       << KTextToHTML::Options(KTextToHTML::PreserveSpaces)
                       << "bla bla bla bla bla";
     QTest::newRow("") << "bla bla bla \n  bla bla bla "
                       << KTextToHTML::Options(KTextToHTML::PreserveSpaces)
                       << "bla bla bla&nbsp;<br />\n&nbsp;&nbsp;bla bla bla&nbsp;";
     QTest::newRow("") << "bla bla  bla"
                       << KTextToHTML::Options(KTextToHTML::PreserveSpaces)
                       << "bla bla&nbsp;&nbsp;bla";
     QTest::newRow("") << " bla bla \n bla bla a\n  bla bla "
                       << KTextToHTML::Options(KTextToHTML::PreserveSpaces)
                       << "&nbsp;bla bla&nbsp;<br />\n&nbsp;bla bla a<br />\n"
                          "&nbsp;&nbsp;bla bla&nbsp;";
 
     // Test highlighting with *, / and _
     QTest::newRow("") << "Ce paragraphe _contient_ des mots ou des _groupes de mots_ à mettre en"
                          " forme…"
                       << KTextToHTML::Options(KTextToHTML::PreserveSpaces | KTextToHTML::HighlightText)
                       << "Ce paragraphe <u>_contient_</u> des mots ou des"
                          " <u>_groupes de mots_</u> à mettre en forme…";
     QTest::newRow("punctation-bug") << "Ce texte *a l'air* de _fonctionner_, à condition"
                                        " d’utiliser le guillemet ASCII."
                                     << KTextToHTML::Options(KTextToHTML::PreserveSpaces | KTextToHTML::HighlightText)
                                     << "Ce texte <b>*a l'air*</b> de <u>_fonctionner_</u>, à"
                                        " condition d’utiliser le guillemet ASCII.";
     QTest::newRow("punctation-bug") << "Un répertoire /est/ un *dossier* où on peut mettre des"
                                        " *fichiers*."
                                     << KTextToHTML::Options(KTextToHTML::PreserveSpaces | KTextToHTML::HighlightText)
                                     << "Un répertoire <i>/est/</i> un"
                                        " <b>*dossier*</b> où on peut mettre des <b>*fichiers*</b>.";
     QTest::newRow("punctation-bug") << "*BLA BLA BLA BLA*."
                                     << KTextToHTML::Options(KTextToHTML::PreserveSpaces | KTextToHTML::HighlightText)
                                     << "<b>BLA BLA BLA BLA</b>.";
     QTest::newRow("") << "Je vais tenter de repérer des faux positif*"
                       << KTextToHTML::Options(KTextToHTML::PreserveSpaces | KTextToHTML::HighlightText)
                       << "Je vais tenter de repérer des faux positif*";
     QTest::newRow("") << "*Ouais !* *Yes!*"
                       << KTextToHTML::Options(KTextToHTML::PreserveSpaces | KTextToHTML::HighlightText)
                       << "<b>*Ouais !*</b> <b>*Yes!*</b>";
     QTest::newRow("") << "the /etc/{rsyslog.d,syslog-ng.d}/package.rpmnew file"
                       << KTextToHTML::Options(KTextToHTML::PreserveSpaces | KTextToHTML::HighlightText)
                       << "the /etc/{rsyslog.d,syslog-ng.d}/package.rpmnew file";
 
     // This test has problems with the encoding, apparently.
     //QTest::newRow( "" ) << "*Ça fait plaisir de pouvoir utiliser des lettres accentuées dans du"
     //                       " texte mis en forme*." << 0x09 << "<b>Ça fait plaisir de pouvoir"
     //                       " utiliser des lettres accentuées dans du texte mis en forme</b>.";
 
     // Bug reported by dfaure, the <hostname> would get lost
     QTest::newRow("") << "QUrl url(\"http://strange<hostname>/\");"
                       << KTextToHTML::Options(KTextToHTML::ReplaceSmileys | KTextToHTML::HighlightText)
                       << "QUrl url(&quot;<a href=\"http://strange<hostname>/\">"
                          "http://strange&lt;hostname&gt;/</a>&quot;);";
 
     // Bug: 211128 - plain text emails should not replace ampersand & with &amp;
     QTest::newRow("bug211128") << "https://green-site/?Ticket=85&Page=next"
                                << KTextToHTML::Options(KTextToHTML::PreserveSpaces)
                                << "<a href=\"https://green-site/?Ticket=85&Page=next\">"
                                   "https://green-site/?Ticket=85&amp;Page=next</a>";
 
     QTest::newRow("dotBeforeEnd") << "Look at this file: www.example.com/example.h"
                                   << KTextToHTML::Options(KTextToHTML::PreserveSpaces)
                                   << "Look at this file: <a href=\"http://www.example.com/example.h\">"
                                      "www.example.com/example.h</a>";
     QTest::newRow("dotInMiddle") << "Look at this file: www.example.com/.bashrc"
                                  << KTextToHTML::Options(KTextToHTML::PreserveSpaces)
                                  << "Look at this file: <a href=\"http://www.example.com/.bashrc\">"
                                     "www.example.com/.bashrc</a>";
 
     // A dot at the end of an URL is explicitly ignored
     QTest::newRow("dotAtEnd") << "Look at this file: www.example.com/test.cpp."
                               << KTextToHTML::Options(KTextToHTML::PreserveSpaces)
                               << "Look at this file: <a href=\"http://www.example.com/test.cpp\">"
                                  "www.example.com/test.cpp</a>.";
 
     // Bug 313719 - URL in parenthesis
     QTest::newRow("url-in-parenthesis-1") << "KDE (website https://www.kde.org)"
                                           << KTextToHTML::Options(KTextToHTML::PreserveSpaces)
                                           << "KDE (website <a href=\"https://www.kde.org\">https://www.kde.org</a>)";
     QTest::newRow("url-in-parenthesis-2") << "KDE website (https://www.kde.org)"
                                           << KTextToHTML::Options(KTextToHTML::PreserveSpaces)
                                           << "KDE website (<a href=\"https://www.kde.org\">https://www.kde.org</a>)";
     QTest::newRow("url-in-parenthesis-3") << "bla (https://www.kde.org - section 5.2)"
                                           << KTextToHTML::Options(KTextToHTML::PreserveSpaces)
                                           << "bla (<a href=\"https://www.kde.org\">https://www.kde.org</a> - section 5.2)";
     
     // Fix url as foo <<url> <url>> when we concatened them.
     QTest::newRow("url-with-url") << "foo <https://www.kde.org/ <https://www.kde.org/>>"
                                   << KTextToHTML::Options(KTextToHTML::PreserveSpaces)
                                   << "foo &lt;<a href=\"https://www.kde.org/ \">https://www.kde.org/ </a>&lt;<a href=\"https://www.kde.org/\">https://www.kde.org/</a>&gt;&gt;";
 
     //Fix url exploit
     QTest::newRow("url-exec-html") << "https://\"><!--"
                                    << KTextToHTML::Options(KTextToHTML::PreserveSpaces)
                                    << "https://&quot;&gt;&lt;!--";
 
     QTest::newRow("url-exec-html-2") << "https://192.168.1.1:\"><!--"
                                      << KTextToHTML::Options(KTextToHTML::PreserveSpaces)
                                      << "https://192.168.1.1:&quot;&gt;&lt;!--";
 
     QTest::newRow("url-exec-html-3") << "https://<IP>:\"><!--"
                                      << KTextToHTML::Options(KTextToHTML::PreserveSpaces)
                                      << "https://&lt;IP&gt;:&quot;&gt;&lt;!--";
 
     QTest::newRow("url-exec-html-4") << "https://<IP>:/\"><!--"
                                      << KTextToHTML::Options(KTextToHTML::PreserveSpaces)
                                      << "https://&lt;IP&gt;:/&quot;&gt;&lt;!--";
 
     QTest::newRow("url-exec-html-5") << "https://<IP>:/\"><script>alert(1);</script><!--"
                                      << KTextToHTML::Options(KTextToHTML::PreserveSpaces)
                                      << "https://&lt;IP&gt;:/&quot;&gt;&lt;script&gt;alert(1);&lt;/script&gt;&lt;!--";
 
     QTest::newRow("url-exec-html-6") << "https://<IP>:/\"><script>alert(1);</script><!--\nTest2"
                                      << KTextToHTML::Options(KTextToHTML::PreserveSpaces)
                                      << "https://&lt;IP&gt;:/&quot;&gt;&lt;script&gt;alert(1);&lt;/script&gt;&lt;!--\nTest2";
 
 
     QTest::newRow("url-with-ref-in-[") << "https://www.kde.org[1]"
                                        << KTextToHTML::Options(KTextToHTML::PreserveSpaces)
                                        << "<a href=\"https://www.kde.org\">https://www.kde.org</a>[1]";
 
     QTest::newRow("url-with-ref-in-[2") << "[http://www.example.org/][whatever]"
                                         << KTextToHTML::Options(KTextToHTML::PreserveSpaces)
                                         << "[<a href=\"http://www.example.org/\">http://www.example.org/</a>][whatever]";
     //Bug 346132
     QTest::newRow("url-with-ref-in-<") << "http://www.foo.bar<http://foo.bar/>"
                                        << KTextToHTML::Options(KTextToHTML::PreserveSpaces)
                                        << "<a href=\"http://www.foo.bar\">http://www.foo.bar</a>&lt;<a href=\"http://foo.bar/\">http://foo.bar/</a>&gt;";
 
     QTest::newRow("url-with-ref-in-]") << "[Please visit our booth 24-25 http://example.com/]"
                                        << KTextToHTML::Options(KTextToHTML::PreserveSpaces)
                                        << "[Please visit our booth 24-25 <a href=\"http://example.com/\">http://example.com/</a>]";
 
     QTest::newRow("two url with space") << "http://www.kde.org/standards/kcfg/1.0 http://www.kde.org/"
                                        << KTextToHTML::Options(KTextToHTML::PreserveSpaces)
                                        << "<a href=\"http://www.kde.org/standards/kcfg/1.0\">http://www.kde.org/standards/kcfg/1.0</a> <a href=\"http://www.kde.org/\">http://www.kde.org/</a>";
 
 
     //Bug kmail
     QTest::newRow("two url with space-2") << "@@ -55,6 +55,10 @@ xsi:schemaLocation=\"http://www.kde.org/standards/kcfg/1.0 http://www.kde.org/"
                                        << KTextToHTML::Options(KTextToHTML::PreserveSpaces)
                                        << "@@ -55,6 +55,10 @@ xsi:schemaLocation=&quot;<a href=\"http://www.kde.org/standards/kcfg/1.0\">http://www.kde.org/standards/kcfg/1.0</a> <a href=\"http://www.kde.org/\">http://www.kde.org/</a>";
 
+    const auto opt = KTextToHTML::PreserveSpaces | KTextToHTML::ConvertPhoneNumbers;
+    // tel: urls
+    QTest::newRow("tel url compact") << "bla bla <tel:+491234567890> bla bla" << opt
+        << "bla bla &lt;<a href=\"tel:+491234567890\">tel:+491234567890</a>&gt; bla bla";
+    QTest::newRow("tel url fancy") << "bla bla tel:+49-321-123456 bla bla" << opt
+        << "bla bla <a href=\"tel:+49-321-123456\">tel:+49-321-123456</a> bla bla";
+
+    // negative tel: url tests
+    QTest::newRow("empty tel url") << "bla tel: blub" << opt
+        << "bla tel: blub";
+
+    // phone numbers
+    QTest::newRow("tel compact international") << "call +49123456789, then hang up" << opt
+        << "call <a href=\"tel:+49123456789\">+49123456789</a>, then hang up";
+    QTest::newRow("tel parenthesis/spaces international") << "phone:+33 (01) 12 34 56 78 blub" << opt
+        << "phone:<a href=\"tel:+330112345678\">+33 (01) 12 34 56 78</a> blub";
+    QTest::newRow("tel dashes international") << "bla +44-321-1-234-567" << opt
+        << "bla <a href=\"tel:+443211234567\">+44-321-1-234-567</a>";
+    QTest::newRow("tel dashes/spaces international") << "+1 123-456-7000 blub" << opt
+        << "<a href=\"tel:+11234567000\">+1 123-456-7000</a> blub";
+    QTest::newRow("tel spaces international") << "bla +32 1 234 5678 blub" << opt
+        << "bla <a href=\"tel:+3212345678\">+32 1 234 5678</a> blub";
+    QTest::newRow("tel slash domestic") << "bla 030/12345678 blub" << opt
+        << "bla <a href=\"tel:03012345678\">030/12345678</a> blub";
+    QTest::newRow("tel slash/space domestic") << "Tel.: 089 / 12 34 56 78" << opt
+        << "Tel.: <a href=\"tel:08912345678\">089 / 12 34 56 78</a>";
+    QTest::newRow("tel follow by parenthesis") << "Telefon: 0 18 05 / 12 23 46 (14 Cent/Min.*)" << opt
+        << "Telefon: <a href=\"tel:01805122346\">0 18 05 / 12 23 46</a> (14 Cent/Min.*)";
+    QTest::newRow("tel space single digit at end") << "0123/123 456 7" << opt
+        << "<a href=\"tel:01231234567\">0123/123 456 7</a>";
+    QTest::newRow("tel space around dash") << "bla +49 (0) 12 23 - 45 6000 blub" << opt
+        << "bla <a href=\"tel:+4901223456000\">+49 (0) 12 23 - 45 6000</a> blub";
+    QTest::newRow("tel two numbers speparated by dash") << "bla +49 (0) 12 23 46 78 - +49 0123/123 456 78 blub" << opt
+        << "bla <a href=\"tel:+49012234678\">+49 (0) 12 23 46 78</a> - <a href=\"tel:+49012312345678\">+49 0123/123 456 78</a> blub";
+
+    // negative tests for phone numbers
+    QTest::newRow("non-tel number") << "please send 1200 cakes" << opt
+        << "please send 1200 cakes";
+    QTest::newRow("non-tel alpha-numeric") << "bla 1-123-456-ABCD blub" << opt
+        << "bla 1-123-456-ABCD blub";
+    QTest::newRow("non-tel alpha prefix") << "ABCD0123-456-789" << opt
+        << "ABCD0123-456-789";
+    QTest::newRow("non-tel date") << "bla 02/03/2019 blub" << opt
+        << "bla 02/03/2019 blub";
+    QTest::newRow("non-tel too long") << "bla +012-4567890123456 blub" << opt
+        << "bla +012-4567890123456 blub";
+    QTest::newRow("non-tel unbalanced") << "bla +012-456789(01 blub" << opt
+        << "bla +012-456789(01 blub";
+    QTest::newRow("non-tel nested") << "bla +012-4(56(78)90)1 blub" << opt
+        << "bla +012-4(56(78)90)1 blub";
+    QTest::newRow("tel extraction disabled") << "call +49123456789 now"
+        << KTextToHTML::Options(KTextToHTML::PreserveSpaces)
+        << "call +49123456789 now";
 }
 
 
 void KTextToHTMLTest::testHtmlConvert()
 {
     QFETCH(QString, plainText);
     QFETCH(KTextToHTML::Options, flags);
     QFETCH(QString, htmlText);
 
     QEXPECT_FAIL("punctation-bug", "Linklocator does not properly detect punctation as boundaries",
                  Continue);
 
     QString actualHtml = KTextToHTML::convertToHtml(plainText, flags);
     QCOMPARE(actualHtml, htmlText);
 }
 
 void KTextToHTMLTest::benchHtmlConvert_data()
 {
     QTest::addColumn<QString>("text");
     QTest::addColumn<KTextToHTML::Options>("options");
 
     auto text = QString(QStringLiteral("foo bar asdf :)")).repeated(1000);
     QTest::newRow("plain") << text << KTextToHTML::Options();
     QTest::newRow("preserve-spaces") << text << KTextToHTML::Options(KTextToHTML::PreserveSpaces);
     QTest::newRow("highlight-text") << text << KTextToHTML::Options(KTextToHTML::HighlightText);
     QTest::newRow("replace-smileys") << text << KTextToHTML::Options(KTextToHTML::ReplaceSmileys);
     QTest::newRow("preserve-spaces+highlight-text") << text << KTextToHTML::Options(KTextToHTML::PreserveSpaces | KTextToHTML::HighlightText);
     QTest::newRow("preserve-spaces+highlight-text+replace-smileys") << text << KTextToHTML::Options(KTextToHTML::PreserveSpaces | KTextToHTML::HighlightText | KTextToHTML::ReplaceSmileys);
 }
 
 void KTextToHTMLTest::benchHtmlConvert()
 {
     QFETCH(QString, text);
     QFETCH(KTextToHTML::Options, options);
 
     QBENCHMARK {
         const QString html = KTextToHTML::convertToHtml(text, options);
         Q_UNUSED(html);
     }
 }
diff --git a/src/lib/text/ktexttohtml.cpp b/src/lib/text/ktexttohtml.cpp
index 28e629e..9541809 100644
--- a/src/lib/text/ktexttohtml.cpp
+++ b/src/lib/text/ktexttohtml.cpp
@@ -1,527 +1,606 @@
 /*
   Copyright (c) 2002 Dave Corrie <kde@davecorrie.com>
   Copyright (c) 2014 Daniel Vrátil <dvratil@redhat.com>
 
   This library is free software; you can redistribute it and/or
   modify it under the terms of the GNU Library General Public
   License as published by the Free Software Foundation; either
   version 2 of the License, or (at your option) any later version.
 
   This library is distributed in the hope that it will be useful,
   but WITHOUT ANY WARRANTY; without even the implied warranty of
   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
   Library General Public License for more details.
 
   You should have received a copy of the GNU Library General Public License
   along with this library; see the file COPYING.LIB.  If not, write to
   the Free Software Foundation, Inc., 51 Franklin Street, Fifth Floor,
   Boston, MA 02110-1301, USA.
 */
 
 #include "ktexttohtml.h"
 #include "ktexttohtml_p.h"
 #include "ktexttohtmlemoticonsinterface.h"
 
 #include <QString>
 #include <QStringList>
 #include <QFile>
 #include <QRegExp>
+#include <QRegularExpression>
 #include <QPluginLoader>
 #include <QVariant>
 #include <QCoreApplication>
 
 #include <limits.h>
 
 #include "kcoreaddons_debug.h"
 
 static KTextToHTMLEmoticonsInterface *s_emoticonsInterface = nullptr;
 
 static void loadEmoticonsPlugin()
 {
     static bool triedLoadPlugin = false;
     if (!triedLoadPlugin) {
         triedLoadPlugin = true;
 
         // Check if QGuiApplication::platformName property exists. This is a
         // hackish way of determining whether we are running QGuiApplication,
         // because we cannot load the FrameworkIntegration plugin into a
         // QCoreApplication, as it would crash immediately
         if (qApp->metaObject()->indexOfProperty("platformName") > -1) {
             QPluginLoader lib(QStringLiteral("kf5/KEmoticonsIntegrationPlugin"));
             QObject *rootObj = lib.instance();
             if (rootObj) {
                 s_emoticonsInterface = rootObj->property(KTEXTTOHTMLEMOTICONS_PROPERTY).value<KTextToHTMLEmoticonsInterface*>();
             }
         }
     }
     if (!s_emoticonsInterface) {
         s_emoticonsInterface = new KTextToHTMLEmoticonsDummy();
     }
 }
 
 
 
 KTextToHTMLHelper::KTextToHTMLHelper(const QString &plainText, int pos, int maxUrlLen, int maxAddressLen)
     : mText(plainText)
     , mMaxUrlLen(maxUrlLen)
     , mMaxAddressLen(maxAddressLen)
     , mPos(pos)
 {
 }
 
 KTextToHTMLEmoticonsInterface* KTextToHTMLHelper::emoticonsInterface() const
 {
     if (!s_emoticonsInterface) {
         loadEmoticonsPlugin();
     }
     return s_emoticonsInterface;
 }
 
 QString KTextToHTMLHelper::getEmailAddress()
 {
     QString address;
 
     if (mText[mPos] == QLatin1Char('@')) {
         // the following characters are allowed in a dot-atom (RFC 2822):
         // a-z A-Z 0-9 . ! # $ % & ' * + - / = ? ^ _ ` { | } ~
         static const QString allowedSpecialChars = QStringLiteral(".!#$%&'*+-/=?^_`{|}~");
 
         // determine the local part of the email address
         int start = mPos - 1;
         while (start >= 0 && mText[start].unicode() < 128 &&
                 (mText[start].isLetterOrNumber() ||
                  mText[start] == QLatin1Char('@') || // allow @ to find invalid email addresses
                  allowedSpecialChars.indexOf(mText[start]) != -1)) {
             if (mText[start] == QLatin1Char('@')) {
                 return QString(); // local part contains '@' -> no email address
             }
             --start;
         }
         ++start;
         // we assume that an email address starts with a letter or a digit
         while ((start < mPos) && !mText[start].isLetterOrNumber()) {
             ++start;
         }
         if (start == mPos) {
             return QString(); // local part is empty -> no email address
         }
 
         // determine the domain part of the email address
         int dotPos = INT_MAX;
         int end = mPos + 1;
         while (end < mText.length() &&
                 (mText[end].isLetterOrNumber() ||
                  mText[end] == QLatin1Char('@') || // allow @ to find invalid email addresses
                  mText[end] == QLatin1Char('.') ||
                  mText[end] == QLatin1Char('-'))) {
             if (mText[end] == QLatin1Char('@')) {
                 return QString(); // domain part contains '@' -> no email address
             }
             if (mText[end] == QLatin1Char('.')) {
                 dotPos = qMin(dotPos, end);   // remember index of first dot in domain
             }
             ++end;
         }
         // we assume that an email address ends with a letter or a digit
         while ((end > mPos) && !mText[end - 1].isLetterOrNumber()) {
             --end;
         }
         if (end == mPos) {
             return QString(); // domain part is empty -> no email address
         }
         if (dotPos >= end) {
             return QString(); // domain part doesn't contain a dot
         }
 
         if (end - start > mMaxAddressLen) {
             return QString(); // too long -> most likely no email address
         }
         address = mText.mid(start, end - start);
 
         mPos = end - 1;
     }
     return address;
 }
 
+QString KTextToHTMLHelper::getPhoneNumber()
+{
+    if (!mText[mPos].isDigit() && mText[mPos] != QLatin1Char('+')) {
+        return {};
+    }
+
+    static const QString allowedBeginSeparators = QStringLiteral(" \r\t\n:");
+    if (mPos > 0 && !allowedBeginSeparators.contains(mText[mPos - 1])) {
+        return {};
+    }
+
+    // this isn't 100% accurate, we filter stuff below that is too hard to capture with a regexp
+    static const QRegularExpression telPattern(QStringLiteral(R"([+0](( |( ?[/-] ?)?)\(?\d+\)?+){6,30})"));
+    const auto match = telPattern.match(mText, mPos, QRegularExpression::NormalMatch, QRegularExpression::AnchoredMatchOption);
+    if (match.hasMatch()) {
+        auto m = match.captured();
+        // check for maximum number of digits (15), see https://en.wikipedia.org/wiki/Telephone_numbering_plan
+        if (std::count_if(m.begin(), m.end(), [](const QChar &c) { return c.isDigit(); }) > 15) {
+            return {};
+        }
+        // only one / is allowed, otherwise we trigger on dates
+        if (std::count(m.begin(), m.end(), QLatin1Char('/')) > 1) {
+            return {};
+        }
+
+        // parenthesis need to be balanced, and must not be nested
+        int openIdx = -1;
+        for (int i = 0; i < m.size(); ++i) {
+            if ((m[i] == QLatin1Char('(') && openIdx >= 0) || (m[i] == QLatin1Char(')') && openIdx < 0)) {
+                return {};
+            }
+            if (m[i] == QLatin1Char('(')) {
+                openIdx = i;
+            } else if (m[i] == QLatin1Char(')')) {
+                openIdx = -1;
+            }
+        }
+        if (openIdx > 0) {
+            m = m.left(openIdx - 1).trimmed();
+        }
+
+        // check if there's a plausible separator at the end
+        static const QString allowedEndSeparators = QStringLiteral(" \r\t\n,.");
+        const auto l = m.size();
+        if (mText.size() > mPos + l && !allowedEndSeparators.contains(mText[mPos + l])) {
+            return {};
+        }
+
+        mPos += l - 1;
+        return m;
+    }
+    return {};
+}
+
+static QString normalizePhoneNumber(const QString &str)
+{
+    QString res;
+    res.reserve(str.size());
+    for (const auto c : str) {
+        if (c.isDigit() || c == QLatin1Char('+')) {
+            res.push_back(c);
+        }
+    }
+    return res;
+}
+
 bool KTextToHTMLHelper::atUrl() const
 {
     // the following characters are allowed in a dot-atom (RFC 2822):
     // a-z A-Z 0-9 . ! # $ % & ' * + - / = ? ^ _ ` { | } ~
     static const QString allowedSpecialChars = QStringLiteral(".!#$%&'*+-/=?^_`{|}~");
 
     // the character directly before the URL must not be a letter, a number or
     // any other character allowed in a dot-atom (RFC 2822).
     if ((mPos > 0) &&
             (mText[mPos - 1].isLetterOrNumber() ||
              (allowedSpecialChars.indexOf(mText[mPos - 1]) != -1))) {
         return false;
     }
     QChar ch = mText[mPos];
     return
         (ch == QLatin1Char('h') && (mText.midRef(mPos, 7) == QLatin1String("http://") ||
                                     mText.midRef(mPos, 8) == QLatin1String("https://"))) ||
         (ch == QLatin1Char('v') && mText.midRef(mPos, 6) == QLatin1String("vnc://")) ||
         (ch == QLatin1Char('f') && (mText.midRef(mPos, 7) == QLatin1String("fish://") ||
                                     mText.midRef(mPos, 6) == QLatin1String("ftp://") ||
                                     mText.midRef(mPos, 7) == QLatin1String("ftps://"))) ||
         (ch == QLatin1Char('s') && (mText.midRef(mPos, 7) == QLatin1String("sftp://") ||
                                     mText.midRef(mPos, 6) == QLatin1String("smb://"))) ||
         (ch == QLatin1Char('m') && mText.midRef(mPos, 7) == QLatin1String("mailto:")) ||
         (ch == QLatin1Char('w') && mText.midRef(mPos, 4) == QLatin1String("www.")) ||
         (ch == QLatin1Char('f') && (mText.midRef(mPos, 4) == QLatin1String("ftp.") ||
                                     mText.midRef(mPos, 7) == QLatin1String("file://"))) ||
-        (ch == QLatin1Char('n') && mText.midRef(mPos, 5) == QLatin1String("news:"));
+        (ch == QLatin1Char('n') && mText.midRef(mPos, 5) == QLatin1String("news:")) ||
+        (ch == QLatin1Char('t') && mText.midRef(mPos, 4) == QLatin1String("tel:"));
+
 }
 
 bool KTextToHTMLHelper::isEmptyUrl(const QString &url) const
 {
     return url.isEmpty() ||
            url == QLatin1String("http://") ||
            url == QLatin1String("https://") ||
            url == QLatin1String("fish://") ||
            url == QLatin1String("ftp://") ||
            url == QLatin1String("ftps://") ||
            url == QLatin1String("sftp://") ||
            url == QLatin1String("smb://") ||
            url == QLatin1String("vnc://") ||
            url == QLatin1String("mailto") ||
            url == QLatin1String("www") ||
            url == QLatin1String("ftp") ||
            url == QLatin1String("news") ||
-           url == QLatin1String("news://");
+           url == QLatin1String("news://") ||
+           url == QLatin1String("tel") ||
+           url == QLatin1String("tel:");
 }
 
 QString KTextToHTMLHelper::getUrl(bool *badurl)
 {
     QString url;
     if (atUrl()) {
         // NOTE: see http://tools.ietf.org/html/rfc3986#appendix-A and especially appendix-C
         // Appendix-C mainly says, that when extracting URLs from plain text, line breaks shall
         // be allowed and should be ignored when the URI is extracted.
 
         // This implementation follows this recommendation and
         // allows the URL to be enclosed within different kind of brackets/quotes
         // If an URL is enclosed, whitespace characters are allowed and removed, otherwise
         // the URL ends with the first whitespace
         // Also, if the URL is enclosed in brackets, the URL itself is not allowed
         // to contain the closing bracket, as this would be detected as the end of the URL
 
         QChar beforeUrl, afterUrl;
 
         // detect if the url has been surrounded by brackets or quotes
         if (mPos > 0) {
             beforeUrl = mText[mPos - 1];
 
             /*if ( beforeUrl == '(' ) {
               afterUrl = ')';
             } else */if (beforeUrl == QLatin1Char('[')) {
                 afterUrl = QLatin1Char(']');
             } else if (beforeUrl == QLatin1Char('<')) {
                 afterUrl = QLatin1Char('>');
             } else if (beforeUrl == QLatin1Char('>')) {   // for e.g. <link>http://.....</link>
                 afterUrl = QLatin1Char('<');
             } else if (beforeUrl == QLatin1Char('"')) {
                 afterUrl = QLatin1Char('"');
             }
         }
         url.reserve(mMaxUrlLen);    // avoid allocs
         int start = mPos;
         bool previousCharIsSpace = false;
         bool previousCharIsADoubleQuote = false;
         bool previousIsAnAnchor = false;
         while ((mPos < mText.length()) &&
                 (mText[mPos].isPrint() || mText[mPos].isSpace()) &&
                 ((afterUrl.isNull() && !mText[mPos].isSpace()) ||
                  (!afterUrl.isNull() && mText[mPos] != afterUrl))) {
             if (!previousCharIsSpace && (mText[mPos] == QLatin1Char('<')) && ((mPos + 1) < mText.length())) {
                 // Fix Bug #346132: allow "http://www.foo.bar<http://foo.bar/>"
                 // < inside a URL is not allowed, however there is a test which
                 // checks that "http://some<Host>/path" should be allowed
                 // Therefore: check if what follows is another URL and if so, stop here
                 mPos++;
                 if (atUrl()) {
                     mPos--;
                     break;
                 }
                 mPos--;
             }
             if (!previousCharIsSpace && (mText[mPos] == QLatin1Char(' ')) && ((mPos + 1) < mText.length())) {
                 // Fix kmail bug: allow "http://www.foo.bar http://foo.bar/"
                 // Therefore: check if what follows is another URL and if so, stop here
                 mPos++;
                 if (atUrl()) {
                     mPos--;
                     break;
                 }
                 mPos--;
             }
             if (mText[mPos].isSpace()) {
                 previousCharIsSpace = true;
             } else if (!previousIsAnAnchor && mText[mPos] == QLatin1Char('[')) {
                 break;
             } else if (!previousIsAnAnchor && mText[mPos] == QLatin1Char(']')) {
                 break;
             } else { // skip whitespace
                 if (previousCharIsSpace && mText[mPos] == QLatin1Char('<')) {
                     url.append(QLatin1Char(' '));
                     break;
                 }
                 previousCharIsSpace = false;
                 if (mText[mPos] == QLatin1Char('>') && previousCharIsADoubleQuote) {
                     //it's an invalid url
                     if (badurl) {
                         *badurl = true;
                     }
                     return QString();
                 }
                 if (mText[mPos] == QLatin1Char('"')) {
                     previousCharIsADoubleQuote = true;
                 } else {
                     previousCharIsADoubleQuote = false;
                 }
                 if (mText[mPos] == QLatin1Char('#')) {
                     previousIsAnAnchor = true;
                 }
                 url.append(mText[mPos]);
                 if (url.length() > mMaxUrlLen) {
                     break;
                 }
             }
 
             ++mPos;
         }
 
         if (isEmptyUrl(url) || (url.length() > mMaxUrlLen)) {
             mPos = start;
             url.clear();
             return url;
         } else {
             --mPos;
         }
     }
 
     // HACK: This is actually against the RFC. However, most people don't properly escape the URL in
     //       their text with "" or <>. That leads to people writing an url, followed immediately by
     //       a dot to finish the sentence. That would lead the parser to include the dot in the url,
     //       even though that is not wanted. So work around that here.
     //       Most real-life URLs hopefully don't end with dots or commas.
     static const QString wordBoundaries = QStringLiteral(".,:!?)>");
     if (url.length() > 1) {
         do {
             if (wordBoundaries.contains(url.at(url.length() - 1))) {
                 url.chop(1);
                 --mPos;
             } else {
                 break;
             }
         } while (url.length() > 1);
     }
     return url;
 }
 
 QString KTextToHTMLHelper::highlightedText()
 {
     // formating symbols must be prepended with a whitespace
     if ((mPos > 0) && !mText[mPos - 1].isSpace()) {
         return QString();
     }
 
     const QChar ch = mText[mPos];
     if (ch != QLatin1Char('/') && ch != QLatin1Char('*') && ch != QLatin1Char('_') && ch != QLatin1Char('-')) {
         return QString();
     }
 
     QRegExp re =
         QRegExp(QStringLiteral("\\%1((\\w+)([\\s-']\\w+)*( ?[,.:\\?!;])?)\\%2").arg(ch).arg(ch));
     re.setMinimal(true);
     if (re.indexIn(mText, mPos) == mPos) {
         int length = re.matchedLength();
         // there must be a whitespace after the closing formating symbol
         if (mPos + length < mText.length() && !mText[mPos + length].isSpace()) {
             return QString();
         }
         mPos += length - 1;
         switch (ch.toLatin1()) {
         case '*':
             return QLatin1String("<b>*") + re.cap(1) + QLatin1String("*</b>");
         case '_':
             return QLatin1String("<u>_") + re.cap(1) + QLatin1String("_</u>");
         case '/':
             return QLatin1String("<i>/") + re.cap(1) + QLatin1String("/</i>");
         case '-':
             return QLatin1String("<strike>-") + re.cap(1) + QLatin1String("-</strike>");
         }
     }
     return QString();
 }
 
 
 QString KTextToHTMLHelper::pngToDataUrl(const QString &iconPath) const
 {
     if (iconPath.isEmpty()) {
         return QString();
     }
 
     QFile pngFile(iconPath);
     if (!pngFile.open(QIODevice::ReadOnly | QIODevice::Unbuffered)) {
         return QString();
     }
 
     QByteArray ba = pngFile.readAll();
     pngFile.close();
     return QStringLiteral("data:image/png;base64,%1").arg(QLatin1String(ba.toBase64().constData()));
 }
 
 
 QString KTextToHTML::convertToHtml(const QString &plainText, const KTextToHTML::Options &flags, int maxUrlLen, int maxAddressLen)
 {
     KTextToHTMLHelper helper(plainText, maxUrlLen, maxAddressLen);
 
     QString str;
     QString result(static_cast<QChar *>(nullptr), helper.mText.length() * 2);
     QChar ch;
     int x;
     bool startOfLine = true;
 
     for (helper.mPos = 0, x = 0; helper.mPos < helper.mText.length();
             ++helper.mPos, ++x) {
         ch = helper.mText[helper.mPos];
         if (flags & PreserveSpaces) {
             if (ch == QLatin1Char(' ')) {
                 if (helper.mPos + 1 < helper.mText.length()) {
                     if (helper.mText[helper.mPos + 1] != QLatin1Char(' ')) {
 
                         // A single space, make it breaking if not at the start or end of the line
                         const bool endOfLine = helper.mText[helper.mPos + 1] == QLatin1Char('\n');
                         if (!startOfLine && !endOfLine) {
                             result += QLatin1Char(' ');
                         } else {
                             result += QLatin1String("&nbsp;");
                         }
                     } else {
 
                         // Whitespace of more than one space, make it all non-breaking
                         while (helper.mPos < helper.mText.length() && helper.mText[helper.mPos] == QLatin1Char(' ')) {
                             result += QLatin1String("&nbsp;");
                             ++helper.mPos;
                             ++x;
                         }
 
                         // We incremented once to often, undo that
                         --helper.mPos;
                         --x;
                     }
                 } else {
                     // Last space in the text, it is non-breaking
                     result += QLatin1String("&nbsp;");
                 }
 
                 if (startOfLine) {
                     startOfLine = false;
                 }
                 continue;
             } else if (ch == QLatin1Char('\t')) {
                 do {
                     result += QLatin1String("&nbsp;");
                     ++x;
                 } while ((x & 7) != 0);
                 --x;
                 startOfLine = false;
                 continue;
             }
         }
         if (ch == QLatin1Char('\n')) {
             result += QLatin1String("<br />\n"); // Keep the \n, so apps can figure out the quoting levels correctly.
             startOfLine = true;
             x = -1;
             continue;
         }
 
         startOfLine = false;
         if (ch == QLatin1Char('&')) {
             result += QLatin1String("&amp;");
         } else if (ch == QLatin1Char('"')) {
             result += QLatin1String("&quot;");
         } else if (ch == QLatin1Char('<')) {
             result += QLatin1String("&lt;");
         } else if (ch == QLatin1Char('>')) {
             result += QLatin1String("&gt;");
         } else {
             const int start = helper.mPos;
             if (!(flags & IgnoreUrls)) {
                 bool badUrl = false;
                 str = helper.getUrl(&badUrl);
                 if (badUrl) {
                     QString resultBadUrl;
                     const int helperTextSize(helper.mText.count());
                     for (int i = 0; i < helperTextSize; ++i) {
                         const QChar chBadUrl = helper.mText[i];
                         if (chBadUrl == QLatin1Char('&')) {
                             resultBadUrl += QLatin1String("&amp;");
                         } else if (chBadUrl == QLatin1Char('"')) {
                             resultBadUrl += QLatin1String("&quot;");
                         } else if (chBadUrl == QLatin1Char('<')) {
                             resultBadUrl += QLatin1String("&lt;");
                         } else if (chBadUrl == QLatin1Char('>')) {
                             resultBadUrl += QLatin1String("&gt;");
                         } else {
                             resultBadUrl += chBadUrl;
                         }
                     }
                     return resultBadUrl;
                 }
                 if (!str.isEmpty()) {
                     QString hyperlink;
                     if (str.left(4) == QLatin1String("www.")) {
                         hyperlink = QLatin1String("http://") + str;
                     } else if (str.left(4) == QLatin1String("ftp.")) {
                         hyperlink = QLatin1String("ftp://") + str;
                     } else {
                         hyperlink = str;
                     }
                     result += QLatin1String("<a href=\"") + hyperlink + QLatin1String("\">") + str.toHtmlEscaped() + QLatin1String("</a>");
                     x += helper.mPos - start;
                     continue;
                 }
                 str = helper.getEmailAddress();
                 if (!str.isEmpty()) {
                     // len is the length of the local part
                     int len = str.indexOf(QLatin1Char('@'));
                     QString localPart = str.left(len);
 
                     // remove the local part from the result (as '&'s have been expanded to
                     // &amp; we have to take care of the 4 additional characters per '&')
                     result.truncate(result.length() -
                                     len - (localPart.count(QLatin1Char('&')) * 4));
                     x -= len;
 
                     result += QLatin1String("<a href=\"mailto:") + str + QLatin1String("\">") + str + QLatin1String("</a>");
                     x += str.length() - 1;
                     continue;
                 }
+                if (flags & ConvertPhoneNumbers) {
+                    str = helper.getPhoneNumber();
+                    if (!str.isEmpty()) {
+                        result += QLatin1String("<a href=\"tel:") + normalizePhoneNumber(str) + QLatin1String("\">") + str + QLatin1String("</a>");
+                        x += str.length() - 1;
+                        continue;
+                    }
+                }
             }
             if (flags & HighlightText) {
                 str = helper.highlightedText();
                 if (!str.isEmpty()) {
                     result += str;
                     x += helper.mPos - start;
                     continue;
                 }
             }
             result += ch;
         }
     }
 
     if (flags & ReplaceSmileys) {
         const QStringList exclude = { QStringLiteral("(c)"), QStringLiteral("(C)"), QStringLiteral("&gt;:-("), QStringLiteral("&gt;:("), QStringLiteral("(B)"), QStringLiteral("(b)"), QStringLiteral("(P)"), QStringLiteral("(p)")
                                       , QStringLiteral("(O)"), QStringLiteral("(o)"), QStringLiteral("(D)"), QStringLiteral("(d)"), QStringLiteral("(E)"), QStringLiteral("(e)"), QStringLiteral("(K)"), QStringLiteral("(k)")
                                       , QStringLiteral("(I)"), QStringLiteral("(i)"), QStringLiteral("(L)"), QStringLiteral("(l)"), QStringLiteral("(8)"), QStringLiteral("(T)"), QStringLiteral("(t)"), QStringLiteral("(G)")
                                       , QStringLiteral("(g)"), QStringLiteral("(F)"), QStringLiteral("(f)"), QStringLiteral("(H)")
                                       , QStringLiteral("8)"), QStringLiteral("(N)"), QStringLiteral("(n)"), QStringLiteral("(Y)"), QStringLiteral("(y)"), QStringLiteral("(U)"), QStringLiteral("(u)"), QStringLiteral("(W)"), QStringLiteral("(w)")
                                       , QStringLiteral("(6)")};
 
         result = helper.emoticonsInterface()->parseEmoticons(result, true, exclude);
     }
 
     return result;
 }
diff --git a/src/lib/text/ktexttohtml.h b/src/lib/text/ktexttohtml.h
index 5164c61..3a343e3 100644
--- a/src/lib/text/ktexttohtml.h
+++ b/src/lib/text/ktexttohtml.h
@@ -1,95 +1,101 @@
 /*
   Copyright (c) 2002 Dave Corrie <kde@davecorrie.com>
   Copyright (c) 2014 Daniel Vrátil <dvratil@redhat.com>
 
   This library is free software; you can redistribute it and/or
   modify it under the terms of the GNU Library General Public
   License as published by the Free Software Foundation; either
   version 2 of the License, or (at your option) any later version.
 
   This library is distributed in the hope that it will be useful,
   but WITHOUT ANY WARRANTY; without even the implied warranty of
   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
   Library General Public License for more details.
 
   You should have received a copy of the GNU Library General Public License
   along with this library; see the file COPYING.LIB.  If not, write to
   the Free Software Foundation, Inc., 51 Franklin Street, Fifth Floor,
   Boston, MA 02110-1301, USA.
 */
 
 #ifndef KCOREADDONS_KTEXTTOHTML_H
 #define KCOREADDONS_KTEXTTOHTML_H
 
 #include <kcoreaddons_export.h>
 
 #include <QString>
 #include <QFlag>
 
 /**
  * @author Dave Corrie \<kde@davecorrie.com\>
  */
 namespace KTextToHTML
 {
 
 /**
  * @since 5.5.0
  */
 enum Option
 {
     /**
      * Preserve white-space formatting of the text
      */
     PreserveSpaces  = 1 << 1,
 
     /**
      * Replace text emoticons smileys by emoticons images.
      *
      * @note
      * This option works only when KEmoticons framework is available at runtime,
      * and requires QGuiApplication, otherwise the flag is simply ignored.
      */
     ReplaceSmileys  = 1 << 2,
 
     /**
      * Don't parse and replace any URLs.
      */
     IgnoreUrls      = 1 << 3,
 
     /**
      * Interpret text highlighting markup, like *bold*, _underline_ and /italic/,
      * and wrap them in corresponding HTML entities.
      */
-    HighlightText   = 1 << 4
+    HighlightText   = 1 << 4,
+
+    /**
+     * Replace phone numbers with tel: links.
+     * @since 5.56.0
+     */
+    ConvertPhoneNumbers = 1 << 5
 };
 Q_DECLARE_FLAGS(Options, Option)
 
 /**
  * Converts plaintext into html. The following characters are converted
  * to HTML entities: & " < >. Newlines are also preserved.
  *
  * @param  plainText  The text to be converted into HTML.
  * @param  options    The options to use when processing @p plainText.
  * @param  maxUrlLen  The maximum length of permitted URLs. The reason for
  *                    this limit is that there may be possible security
  *                    implications in handling URLs of unlimited length.
  * @param  maxAddressLen  The maximum length of permitted email addresses.
  *                    The reason for this limit is that there may be possible
  *                    security implications in handling addresses of unlimited
  *                    length.
  *
  * @return An HTML version of the text supplied in the 'plainText'
  * parameter, suitable for inclusion in the BODY of an HTML document.
  *
  * @since 5.5.0
  */
 KCOREADDONS_EXPORT QString convertToHtml(const QString &plainText,
                                          const KTextToHTML::Options &options,
                                          int maxUrlLen = 4096,
                                          int maxAddressLen = 255);
 
 }
 
 Q_DECLARE_OPERATORS_FOR_FLAGS(KTextToHTML::Options)
 
 #endif
diff --git a/src/lib/text/ktexttohtml_p.h b/src/lib/text/ktexttohtml_p.h
index d255d27..06d6a5c 100644
--- a/src/lib/text/ktexttohtml_p.h
+++ b/src/lib/text/ktexttohtml_p.h
@@ -1,62 +1,63 @@
 /*
   Copyright (c) 2002 Dave Corrie <kde@davecorrie.com>
   Copyright (c) 2014 Daniel Vrátil <dvratil@redhat.com>
 
   This library is free software; you can redistribute it and/or
   modify it under the terms of the GNU Library General Public
   License as published by the Free Software Foundation; either
   version 2 of the License, or (at your option) any later version.
 
   This library is distributed in the hope that it will be useful,
   but WITHOUT ANY WARRANTY; without even the implied warranty of
   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
   Library General Public License for more details.
 
   You should have received a copy of the GNU Library General Public License
   along with this library; see the file COPYING.LIB.  If not, write to
   the Free Software Foundation, Inc., 51 Franklin Street, Fifth Floor,
   Boston, MA 02110-1301, USA.
 */
 
 #ifndef KTEXTTOHTML_P_H
 #define KTEXTTOHTML_P_H
 
 #include <QObject>
 
 #include "kcoreaddons_export.h"
 #include "ktexttohtmlemoticonsinterface.h"
 
 class KTextToHTMLEmoticonsDummy : public KTextToHTMLEmoticonsInterface
 {
 public:
     QString parseEmoticons(const QString &text,
                            bool strictParse = false,
                            const QStringList &exclude = QStringList()) override
     {
         Q_UNUSED(strictParse);
         Q_UNUSED(exclude);
         return text;
     }
 };
 
 class KTextToHTMLHelper
 {
 public:
     KTextToHTMLHelper(const QString &plainText, int pos = 0, int maxUrlLen = 4096, int maxAddressLen = 255);
 
     KTextToHTMLEmoticonsInterface *emoticonsInterface() const;
 
     QString getEmailAddress();
+    QString getPhoneNumber();
     bool atUrl() const;
     bool isEmptyUrl(const QString &url) const;
     QString getUrl(bool *badurl = nullptr);
     QString pngToDataUrl(const QString &pngPath) const;
     QString highlightedText();
 
     QString mText;
     int mMaxUrlLen;
     int mMaxAddressLen;
     int mPos;
 };
 
 #endif