Fixed a stoll bug that was there since day one, html parser, fix pkgconfig

2026-09-30 08:44:13 +00:00 · 2026-09-22 11:09:50 -05:00
parent 5b54af1728
commit dbeae862c5
21 changed files with 1016 additions and 80 deletions
@@ -39,6 +39,8 @@
 #include "TessesFramework/Filesystem/VFS.hpp"
 #include "TessesFramework/Filesystem/VFSFix.hpp"
 // clang-format on
+
+#include "TessesFramework/Serialization/BitConverter.hpp"
 using FileStream = Tesses::Framework::Streams::FileStream;
 using Stream = Tesses::Framework::Streams::Stream;
 using SeekOrigin = Tesses::Framework::Streams::SeekOrigin;
@@ -607,12 +609,34 @@ uint16_t HttpServer::GetPort() {
        return server->GetPort();
    return 0;
 }
+
 std::shared_ptr<Stream> ServerContext::OpenResponseStream() {
    if (sent)
        return nullptr;
    int64_t length = -1;
-    if (!this->responseHeaders.TryGetFirstInt("Content-Length", length))
-        length = -1;
+    try {
+        if (!this->responseHeaders.TryGetFirstInt("Content-Length", length))
+            length = -1;
+    } catch (std::invalid_argument &invalid) {
+        std::string error =
+            "<!DOCTYPE html><html lang=\"en\"><head><meta "
+            "charset=\"UTF-8\"> <meta name=\"viewport\" "
+            "content=\"width=device-width, "
+            "initial-scale=1.0\"><title>Internal Server Error at " +
+            HttpUtils::HtmlEncode(this->originalPath) +
+            "</title><meta name=\"color-scheme\" content=\"dark "
+            "light\"></head><body><h1>Internal Server Error at " +
+            HttpUtils::HtmlEncode(this->originalPath) +
+            "</h1><p>what(): " + HttpUtils::HtmlEncode(invalid.what()) +
+            "</p></body></html>";
+        this->responseHeaders.SetValue("Content-Length",
+                                       static_cast<int64_t>(error.size()));
+        this->statusCode = StatusCode::InternalServerError;
+        this->WriteHeaders();
+        this->strm->WriteBlock(reinterpret_cast<const uint8_t *>(error.data()),
+                               error.size());
+        return nullptr;
+    }

    if (this->version == "HTTP/1.1" && length == -1)
        this->responseHeaders.SetValue("Transfer-Encoding", "chunked");
@@ -648,6 +672,10 @@ void HttpServer::StartAccepting() {
            uint16_t port;
            auto sock = svr->GetStream(ip, port);

+            if (!TF_IsRunning()) // we need to die, that continue is not what we
+                                 // want if we must die from being done
+                break;
+
            TF_LOG("New Host IP: " + ip + ":" + std::to_string(port));

            if (sock == nullptr) {
@@ -708,9 +736,14 @@ ServerContext::ServerContext(std::shared_ptr<Stream> strm, bool debug)
 }
 std::shared_ptr<Stream> ServerContext::GetStream() { return this->strm; }
 void ServerContext::SendBytes(std::vector<uint8_t> buff) {
-    std::shared_ptr<MemoryStream> strm = std::make_shared<MemoryStream>(false);
-    strm->GetBuffer() = buff;
-    SendStream(strm);
+
+    if (sent)
+        return;
+    this->responseHeaders.SetValue("Content-Length",
+                                   static_cast<int64_t>(buff.size()));
+    auto resp = OpenResponseStream();
+    if (resp)
+        resp->WriteBlock(buff.data(), buff.size());
 }
 ServerContext &ServerContext::WithLastModified(Date::DateTime dt) {
    this->responseHeaders.SetValue("Last-Modified", dt);
@@ -718,11 +751,13 @@ ServerContext &ServerContext::WithLastModified(Date::DateTime dt) {
 }

 void ServerContext::SendText(std::string text) {
-    std::shared_ptr<MemoryStream> strm = std::make_shared<MemoryStream>(false);
-
-    auto &buff = strm->GetBuffer();
-    buff.insert(buff.end(), text.begin(), text.end());
-    SendStream(strm);
+    if (sent)
+        return;
+    this->responseHeaders.SetValue("Content-Length",
+                                   static_cast<int64_t>(text.size()));
+    auto resp = OpenResponseStream();
+    if (resp)
+        resp->WriteBlock(reinterpret_cast<uint8_t *>(text.data()), text.size());
 }
 void ServerContext::SendErrorPage(bool showPath) {
    if (sent)
@@ -792,22 +827,34 @@ void ServerContext::SendStream(std::shared_ptr<Stream> strm) {
                int64_t begin = 0;
                int64_t end = -1;

-                if (dash.size() == 1 &&
-                    res[0].find_first_of('-') != std::string::npos) {
-                    // NUMBER-
-                    begin = std::stoll(dash[0]);
-                } else if (dash.size() == 2) {
+                if (dash.size() == 2) {
                    // NUMBER-NUMBER
                    // or
                    //-NUMBER
-
-                    if (dash[0].size() > 0) {
-                        // NUMBER-NUMBER
-                        begin = std::stoll(dash[0]);
-                        end = std::stoll(dash[1]);
-                    } else {
+                    if (dash[0].empty()) {
                        //-NUMBER
-                        end = std::stoll(dash[1]);
+
+                        if (!Serialization::BitConverter::TryParseSigned(
+                                dash[1], end))
+                            throw std::runtime_error(
+                                "Failed to parse the end of the Range header");
+                    } else if (dash[1].empty()) {
+                        if (!Serialization::BitConverter::TryParseSigned(
+                                dash[0], begin))
+                            throw std::runtime_error(
+                                "Failed to parse the end of the Range header");
+                    } else {
+                        // NUMBER-NUMBER
+                        if (!Serialization::BitConverter::TryParseSigned(
+                                dash[0], begin))
+                            throw std::runtime_error(
+                                "Failed to parse the beginning of the Range "
+                                "header");
+
+                        if (!Serialization::BitConverter::TryParseSigned(
+                                dash[1], end))
+                            throw std::runtime_error(
+                                "Failed to parse the end of the Range header");
                    }
                } else {
                    this->statusCode = BadRequest;
@@ -886,6 +933,8 @@ void ServerContext::SendStream(std::shared_ptr<Stream> strm) {
    } else {

        auto chunkedStream = this->OpenResponseStream();
+        if (!chunkedStream)
+            throw std::runtime_error("Can't open response stream");

        if (method != "HEAD")
            strm->CopyTo(chunkedStream);
@@ -945,24 +994,28 @@ ServerContext &ServerContext::WithStatusCode(StatusCode code) {
    this->statusCode = code;
    return *this;
 }
-void ServerContext::SendException(std::exception &ex) {
-    if (this->debug) {
+void ServerContext::SendException(const std::exception &ex) {
+    try {
+        if (this->debug) {

-        this->WithMimeType("text/html")
-            .WithStatusCode(StatusCode::InternalServerError)
-            .SendText("<!DOCTYPE html><html lang=\"en\"><head><meta "
-                      "charset=\"UTF-8\"> <meta name=\"viewport\" "
-                      "content=\"width=device-width, "
-                      "initial-scale=1.0\"><title>Internal Server Error at " +
-                      HttpUtils::HtmlEncode(this->originalPath) +
-                      "</title><meta name=\"color-scheme\" content=\"dark "
-                      "light\"></head><body><h1>Internal Server Error at " +
-                      HttpUtils::HtmlEncode(this->originalPath) +
-                      "</h1><p>what(): " + HttpUtils::HtmlEncode(ex.what()) +
-                      "</p></body></html>");
-    } else {
-        this->WithStatusCode(StatusCode::InternalServerError)
-            .SendErrorPage(true);
+            this->WithMimeType("text/html")
+                .WithStatusCode(StatusCode::InternalServerError)
+                .SendText(
+                    "<!DOCTYPE html><html lang=\"en\"><head><meta "
+                    "charset=\"UTF-8\"> <meta name=\"viewport\" "
+                    "content=\"width=device-width, "
+                    "initial-scale=1.0\"><title>Internal Server Error at " +
+                    HttpUtils::HtmlEncode(this->originalPath) +
+                    "</title><meta name=\"color-scheme\" content=\"dark "
+                    "light\"></head><body><h1>Internal Server Error at " +
+                    HttpUtils::HtmlEncode(this->originalPath) +
+                    "</h1><p>what(): " + HttpUtils::HtmlEncode(ex.what()) +
+                    "</p></body></html>");
+        } else {
+            this->WithStatusCode(StatusCode::InternalServerError)
+                .SendErrorPage(true);
+        }
+    } catch (...) {
    }
 }

@@ -1106,6 +1159,13 @@ void HttpServer::Process(std::shared_ptr<Stream> strm,
            ctx.requestHeaders.TryGetFirst("Content-Type", type) &&
            type == "application/x-www-form-urlencoded" &&
            ctx.requestHeaders.TryGetFirstInt("Content-Length", length)) {
+
+            if (length <= 0) {
+                ctx.statusCode = StatusCode::BadRequest;
+                ctx.SendErrorPage(true);
+                return;
+            }
+
            size_t len = (size_t)length;
            std::vector<uint8_t> buffer(len);
            len = bStrm->ReadBlock(buffer.data(), len);
@@ -21,14 +21,19 @@

 #include "TessesFramework/Http/HttpUtils.hpp"
 #include "TessesFramework/Filesystem/VFS.hpp"
+#include "TessesFramework/Serialization/BitConverter.hpp"
+#include "TessesFramework/Text/StringConverter.hpp"
 #include <algorithm>
 #include <iostream>
 #include <sstream>
 using VFSPath = Tesses::Framework::Filesystem::VFSPath;
 namespace Tesses::Framework::Http {

-bool Uri::Relative(std::string url, Uri &uri) {
-    auto index = url.find_first_of("//");
+bool Uri::Relative(std::string_view url, Uri &uri) {
+    auto path = this->path;
+    if (path.empty())
+        path = "/";
+    auto index = url.find("//");
    if (index != std::string::npos) {
        if (Uri::TryParse(url, uri)) {
            if (index == 0)
@@ -63,7 +68,10 @@ bool Uri::Relative(std::string url, Uri &uri) {

            auto fourthPart = HttpUtils::SplitString(thirdPart[1], "?", 2);

-            VFSPath p = VFSPath(this->path, fourthPart[0]);
+            VFSPath p =
+                VFSPath(path, (path.back() == '/' || fourthPart[0].empty())
+                                  ? fourthPart[0]
+                                  : "../" + fourthPart[0]);
            uri.path =
                p.CollapseRelativeParents().ToString(); // this should be safe
            if (fourthPart.size() == 2) {
@@ -98,21 +106,33 @@ uint16_t Uri::GetPort() {
        return 69;
    return 0;
 }
-bool Uri::TryParse(std::string url, Uri &uri) {
+bool Uri::TryParse(std::string_view url, Uri &uri) {
    uri.scheme = "";
    uri.port = 0;
    auto firstPart = HttpUtils::SplitString(url, "//", 2);
    if (firstPart.size() == 2)

        uri.scheme = firstPart[0];
-    else if (firstPart.empty())
+    else
        return false;

-    auto secondPart = HttpUtils::SplitString(
-        firstPart.size() == 2 ? firstPart[1] : firstPart[0], "/", 2);
+    auto secondPart = HttpUtils::SplitString(firstPart[1], "/", 2);

    if (secondPart.size() == 1) {
        uri.path = "/";
+        auto hp = secondPart[0];
+        auto fragPart = HttpUtils::SplitString(hp, "#", 2);
+        if (fragPart.size() == 2) {
+            uri.hash = fragPart[1];
+            hp = fragPart[0];
+        }
+        auto queryPart = HttpUtils::SplitString(hp, "?", 2);
+        if (queryPart.size() == 2) {
+            HttpUtils::QueryParamsDecode(uri.query, queryPart[1]);
+            hp = queryPart[0];
+        }
+        secondPart[0] = hp;
+
    } else if (secondPart.size() == 2) {
        auto thirdPart = HttpUtils::SplitString(secondPart[1], "#", 2);
        if (thirdPart.empty())
@@ -135,14 +155,25 @@ bool Uri::TryParse(std::string url, Uri &uri) {
    if (hostPortPart.empty())
        return false;
    if (hostPortPart.size() == 2) {
-        uri.port = (uint16_t)std::stoul(hostPortPart[1]);
+        uint64_t portNum;
+        if (!Serialization::BitConverter::TryParseUnsigned(hostPortPart[1],
+                                                           portNum))
+            return false;
+        if (portNum > 65535)
+            return false;
+        uri.port = static_cast<uint16_t>(portNum);
    }
    uri.host = hostPortPart[0];

    return true;
 }
 Uri::Uri() : query(true) {}
-std::string Uri::GetPathAndQuery() { return this->path + this->GetQuery(); }
+std::string Uri::GetPathAndQuery() {
+    if (this->path.empty() || this->path.front() != '/')
+        return '/' + this->path + this->GetQuery();
+
+    return this->path + this->GetQuery();
+}
 std::string Uri::GetQuery() {
    if (this->query.kvp.empty())
        return "";
@@ -532,9 +563,16 @@ std::string HttpUtils::HtmlP(std::string_view text) {

    auto flush = [&]() -> void {
        if (!builder.empty()) {
+            // Collect trailing punctuation
+            std::string trailing;
+            static const char *punct = ".,;:!?'\"";
+            while (!builder.empty() && std::strchr(punct, builder.back())) {
+                trailing.insert(trailing.begin(), builder.back());
+                builder.pop_back();
+            }
            if (builder.find("http://") == 0 || builder.find("https://") == 0 ||
                builder.find("ftp://") == 0 || builder.find("ftps://") == 0 ||
-                builder.find("magnet:") == 0 || builder.find("btmh:") == 0) {
+                builder.find("magnet:") == 0) {
                newText += "<a href=\"" + HttpUtils::HtmlEncode(builder) +
                           "\">" + HttpUtils::HtmlEncode(builder) + "</a>";
            } else if (builder.find("mailto:") == 0) {
@@ -548,6 +586,7 @@ std::string HttpUtils::HtmlP(std::string_view text) {
            } else {
                newText += HttpUtils::HtmlEncode(builder);
            }
+            newText += HttpUtils::HtmlEncode(trailing);
            builder = "";
        }
    };
@@ -564,7 +603,7 @@ std::string HttpUtils::HtmlP(std::string_view text) {
            break;
        case '\t':
            flush();
-            newText += "&tab;";
+            newText += "&nbsp;&nbsp;&nbsp;&nbsp;";
            break;
        case '\r':
            flush();
@@ -578,6 +617,106 @@ std::string HttpUtils::HtmlP(std::string_view text) {

    return newText;
 }
+static std::unordered_map<std::string, std::string> htmlencodings = {
+    {"&quot;", "\""},
+    {"&apos;", "'"},
+    {"&amp;", "&"},
+    {"&lt;", "<"},
+    {"&gt;", ">"},
+    {"&nbsp;", "\xC2\xA0"},
+    {"&copy;", "\xC2\xA9"},
+    {"&reg;", "\xC2\xAE"},
+    {"&trade;", "\xE2\x84\xA2"},
+    {"&mdash;", "\xE2\x80\x94"},
+    {"&ndash;", "\xE2\x80\x93"},
+    {"&hellip;", "\xE2\x80\xA6"},
+    {"&rsquo;", "\xE2\x80\x99"},
+    {"&lsquo;", "\xE2\x80\x98"},
+    {"&rdquo;", "\xE2\x80\x9D"},
+    {"&ldquo;", "\xE2\x80\x9C"},
+    {"&euro;", "\xE2\x82\xAC"},
+    {"&pound;", "\xC2\xA3"},
+    {"&yen;", "\xC2\xA5"},
+    {"&deg;", "\xC2\xB0"},
+    {"&plusmn;", "\xC2\xB1"},
+    {"&times;", "\xC3\x97"},
+    {"&divide;", "\xC3\xB7"},
+    {"&laquo;", "\xC2\xAB"},
+    {"&raquo;", "\xC2\xBB"},
+    {"&bull;", "\xE2\x80\xA2"},
+    {"&middot;", "\xC2\xB7"},
+    {"&frac12;", "\xC2\xBD"},
+    {"&frac14;", "\xC2\xBC"},
+    {"&frac34;", "\xC2\xBE"},
+};
+std::string HttpUtils::HtmlDecode(std::string_view view) {
+    std::string myHtml = {};
+    std::string tmp = {};
+    bool inEscaped = false;
+    for (size_t i = 0; i < view.size(); i++) {
+        if (inEscaped) {
+            if (view[i] == ';') {
+                inEscaped = false;
+
+                if (tmp.size() > 2 && tmp[1] == '#') //&#N
+                {
+                    if (tmp[2] == 'x' || tmp[2] == 'X') {
+                        auto res = tmp.substr(3);
+                        uint64_t code;
+                        if (Serialization::BitConverter::TryParseUnsigned(
+                                res, code, 16)) {
+                            if (code <= 0x10FFFF &&
+                                (code < 0xD800 || code > 0xDFFF)) {
+                                Text::StringConverter::UTF8::FromUTF32(
+                                    myHtml, {static_cast<char32_t>(code)});
+                            } else {
+                                myHtml += "\xEF\xBF\xBD";
+                            }
+                        } else {
+                            myHtml += "\xEF\xBF\xBD";
+                        }
+                    } else {
+                        auto res = tmp.substr(2);
+                        uint64_t code;
+                        if (Serialization::BitConverter::TryParseUnsigned(
+                                res, code, 10)) {
+                            if (code <= 0x10FFFF &&
+                                (code < 0xD800 || code > 0xDFFF)) {
+                                Text::StringConverter::UTF8::FromUTF32(
+                                    myHtml, {static_cast<char32_t>(code)});
+                            } else {
+                                myHtml += "\xEF\xBF\xBD";
+                            }
+                        } else {
+                            myHtml += "\xEF\xBF\xBD";
+                        }
+                    }
+                } else {
+                    tmp += ';';
+                    auto result = htmlencodings.find(tmp);
+                    if (result != htmlencodings.end()) {
+                        myHtml += result->second;
+                    } else {
+                        myHtml += "\xEF\xBF\xBD";
+                    }
+                }
+            } else {
+                tmp += view[i];
+            }
+        } else {
+            if (view[i] == '&') {
+                tmp = "&";
+                inEscaped = true;
+            } else {
+                myHtml += view[i];
+            }
+        }
+    }
+    if (inEscaped)
+        myHtml += tmp;
+    return myHtml;
+}
+
 std::string HttpUtils::HtmlEncode(std::string_view html) {
    std::string myHtml = {};
    for (auto item : html) {
@@ -838,16 +977,8 @@ bool HttpDictionary::TryGetFirstInt(std::string key, int64_t &value) {
    std::string val;
    if (!TryGetFirst(key, val))
        return false;
-    try {
-        size_t off = 0;
-        auto v = std::stoll(val, &off);
-        if (off != val.size())
-            return false;
-        value = v;
-    } catch (std::exception &ex) {
-        return false;
-    }
-    return true;
+
+    return Serialization::BitConverter::TryParseSigned(val, value);
 }
 bool HttpDictionary::TryGetFirstDate(std::string key, Date::DateTime &dt) {
    std::string val;
@@ -284,4 +284,61 @@ void BitConverter::FromSint16LE(uint8_t &b, int16_t v) {
    memcpy(&dest, &v, sizeof(uint16_t));
    FromUint16LE(b, dest);
 }
+
+bool BitConverter::TryParseSigned(const std::string &str, int64_t &val,
+                                  int base) {
+    try {
+        if (str.find_first_not_of(" \t") != 0)
+            return false;
+        size_t pos = 0;
+        int64_t v = std::stoll(str, &pos, base);
+        if (pos < str.size())
+            return false;
+        val = v;
+        return true;
+    } catch (std::out_of_range &arg) {
+        return false;
+    } catch (std::invalid_argument &arg) {
+        return false;
+    }
+}
+bool BitConverter::TryParseUnsigned(const std::string &str, uint64_t &val,
+                                    int base) {
+    try {
+
+        if (str.find_first_not_of(" \t") != 0)
+            return false;
+        if (str[0] == '-' || str[0] == '+')
+            return false;
+        size_t pos = 0;
+        uint64_t v = std::stoull(str, &pos, base);
+        if (pos < str.size())
+            return false;
+        val = v;
+        return true;
+    } catch (std::out_of_range &arg) {
+        return false;
+    } catch (std::invalid_argument &arg) {
+        return false;
+    }
+}
+bool BitConverter::TryParseDouble(const std::string &str, double &val) {
+    try {
+
+        if (str.find_first_not_of(" \t") != 0)
+            return false;
+
+        size_t pos = 0;
+        double v = std::stod(str, &pos);
+        if (pos < str.size())
+            return false;
+        val = v;
+        return true;
+    } catch (std::out_of_range &arg) {
+        return false;
+    } catch (std::invalid_argument &arg) {
+        return false;
+    }
+}
+
 } // namespace Tesses::Framework::Serialization
@@ -0,0 +1,429 @@
+#include "TessesFramework/Serialization/Html.hpp"
+#include "TessesFramework/Console.hpp"
+#include "TessesFramework/Http/HttpUtils.hpp"
+#include <unordered_set>
+namespace Tesses::Framework::Serialization::Html {
+
+static std::unordered_set<std::string> html_nodes_with_no_body = {
+    "area",  "base", "br",   "col",    "embed", "hr",  "img",
+    "input", "link", "meta", "source", "track", "wbr",
+};
+std::string HtmlNode::ToString() const {
+    std::string text;
+    HtmlNode::ToString(text);
+    return text;
+}
+
+void HtmlNode::InnerText(std::string &str) const {
+    if (this->isText) {
+        str += this->text_or_tag;
+    } else {
+        for (const auto &item : this->children)
+            item->InnerText(str);
+    }
+}
+
+std::string HtmlNode::InnerText() const {
+    std::string innerText;
+    InnerText(innerText);
+    return innerText;
+}
+
+void HtmlNode::ToString(std::string &str) const {
+    if (this->isText) {
+        str += Http::HttpUtils::HtmlEncode(this->text_or_tag);
+    } else {
+        str += "<";
+        str += this->text_or_tag;
+        for (auto &attr : this->attributes) {
+            str += ' ';
+            str += attr.first;
+            if (attr.second) {
+                str += "=\"";
+                str += Http::HttpUtils::HtmlEncode(attr.second.value());
+                str += "\"";
+            }
+        }
+        str += ">";
+
+        if (html_nodes_with_no_body.count(this->text_or_tag) == 0) {
+            for (auto &child : this->children)
+                child->ToString(str);
+
+            str += "</";
+            str += this->text_or_tag;
+            str += ">";
+        }
+    }
+}
+std::shared_ptr<HtmlNode> HtmlNode::FromText(std::string_view text) {
+    auto node = std::make_shared<HtmlNode>();
+    node->isText = true;
+    node->text_or_tag = std::string{text};
+    return node;
+}
+std::shared_ptr<HtmlNode> HtmlNode::FromNode(
+    std::string_view name,
+    std::initializer_list<std::pair<std::string, std::optional<std::string>>>
+        attrs,
+    std::initializer_list<std::shared_ptr<HtmlNode>> nodes) {
+    return HtmlNode::FromNode(name, attrs.begin(), attrs.end(), nodes.begin(),
+                              nodes.end());
+}
+
+std::shared_ptr<HtmlNode> HtmlNode::FromNode(
+    std::string_view name,
+    std::vector<std::pair<std::string, std::optional<std::string>>> attrs,
+    std::vector<std::shared_ptr<HtmlNode>> nodes) {
+    return HtmlNode::FromNode(name, attrs.begin(), attrs.end(), nodes.begin(),
+                              nodes.end());
+}
+
+void HtmlNode::FindNodes(
+    std::string_view tag,
+    std::vector<std::shared_ptr<const HtmlNode>> &nodes) const {
+    if (!this->isText) {
+        if (this->text_or_tag == tag)
+            nodes.push_back(this->shared_from_this());
+        for (const auto &node : this->children)
+            node->FindNodes(tag, nodes);
+    }
+}
+
+std::vector<std::shared_ptr<const HtmlNode>>
+HtmlNode::FindNodes(std::string_view tag) const {
+    std::vector<std::shared_ptr<const HtmlNode>> nodes;
+    FindNodes(tag, nodes);
+    return nodes;
+}
+
+enum class HtmlLexTokenType { SYMBOL, TEXT, STRING };
+struct HtmlLexToken {
+    std::string text;
+    HtmlLexTokenType type;
+    HtmlLexToken(HtmlLexTokenType type, std::string_view text)
+        : text(text), type(type) {}
+};
+
+struct HtmlLexer {
+    std::shared_ptr<TextStreams::TextReader> reader;
+    std::vector<HtmlLexToken> &tokens;
+    int32_t _peeked = -1;
+    std::string builder;
+    bool ignoreSpaceMode = false;
+    std::string nodeName = {};
+
+    HtmlLexer(std::shared_ptr<TextStreams::TextReader> reader,
+              std::vector<HtmlLexToken> &tokens)
+        : reader(std::move(reader)), tokens(tokens) {}
+
+    int32_t Peek() {
+        if (_peeked != -1)
+            return _peeked;
+        _peeked = Read();
+        return _peeked;
+    }
+
+    int64_t Read() {
+        if (_peeked != -1) {
+            auto tmp = _peeked;
+            _peeked = -1;
+            return tmp;
+        }
+
+        return reader->ReadChar();
+    }
+
+    void Flush() {
+        if (!builder.empty()) {
+            this->tokens.emplace_back(HtmlLexTokenType::TEXT, builder);
+
+            if (ignoreSpaceMode && nodeName.empty())
+                nodeName = builder;
+
+            builder = "";
+        }
+    }
+
+    void SkipTo(std::string_view fmt) {
+        if (fmt.empty())
+            return;
+        std::string window;
+        window.resize(fmt.size());
+
+        while (fmt != window) {
+            int32_t read = Read();
+            if (read == -1)
+                break;
+            for (size_t i = 0; i < window.size() - 1; i++) {
+                window[i] = window[i + 1];
+            }
+
+            window.back() = static_cast<char>(read);
+        }
+    }
+
+    void Lex() {
+        int read;
+        while ((read = Read()) != -1) {
+            int peek = Peek();
+            switch (read) {
+            case '"':
+            case '\'': {
+                if (ignoreSpaceMode) {
+                    Flush();
+                    char quote = static_cast<char>(read);
+                    std::string val;
+                    int c;
+                    while ((c = Read()) != -1 && c != quote)
+                        val += static_cast<char>(c);
+                    tokens.emplace_back(HtmlLexTokenType::STRING, val);
+                } else {
+                    builder += static_cast<char>(read);
+                }
+                break;
+            }
+            case '/': {
+                if (ignoreSpaceMode && peek == '>') {
+                    Flush();
+                    Read();
+                    ignoreSpaceMode = false;
+                    tokens.emplace_back(HtmlLexTokenType::SYMBOL, "/>");
+                } else if (ignoreSpaceMode) {
+                    builder += '/';
+                } else {
+                    builder += '/';
+                }
+                break;
+            }
+            case '>': {
+                if (ignoreSpaceMode) {
+                    Flush();
+                    ignoreSpaceMode = false;
+                    tokens.emplace_back(HtmlLexTokenType::SYMBOL, ">");
+
+                    if (nodeName == "script" || nodeName == "style") {
+                        nodeName = "_";
+                        std::string builder2 = "";
+                        bool eof = false;
+                        while ((read = Read()) != -1) {
+                            if (read == '<') {
+                                peek = Peek();
+                                if (peek == '/') {
+                                    Read();
+                                    break;
+                                } else if (peek == -1) {
+                                    eof = true;
+                                    break;
+                                } else {
+                                    builder2 += '<';
+                                }
+                            } else {
+                                builder2 += static_cast<char>(read);
+                            }
+                        }
+
+                        if (read != -1 && !eof) {
+                            tokens.emplace_back(HtmlLexTokenType::TEXT,
+                                                builder2);
+
+                            ignoreSpaceMode = true;
+                            tokens.emplace_back(HtmlLexTokenType::SYMBOL, "</");
+
+                        } else {
+                            return;
+                        }
+                    }
+
+                } else {
+                    builder += '>';
+                }
+            } break;
+            case '<': {
+                Flush();
+                if (peek == '!') {
+                    //<!-- -->
+                    //<!DOCTYPE html>
+                    Read();
+                    peek = Peek();
+                    if (peek == '-') {
+                        Read();
+                        peek = Peek();
+                        if (peek == '-') {
+                            Read();
+                            SkipTo("-->");
+
+                        } else {
+                            SkipTo(">");
+                        }
+                    } else {
+                        SkipTo(">");
+                    }
+
+                } else if (peek == '/') {
+                    Read();
+
+                    ignoreSpaceMode = true;
+                    tokens.emplace_back(HtmlLexTokenType::SYMBOL, "</");
+                } else {
+
+                    ignoreSpaceMode = true;
+                    tokens.emplace_back(HtmlLexTokenType::SYMBOL, "<");
+                    nodeName = {};
+                }
+            } break;
+            case '=': {
+                if (!ignoreSpaceMode) {
+                    builder += "=";
+                } else {
+                    Flush();
+                    tokens.emplace_back(HtmlLexTokenType::SYMBOL, "=");
+                }
+            } break;
+            case ' ':
+            case '\n':
+            case '\t':
+            case '\r':
+                if (!ignoreSpaceMode) {
+                    builder += static_cast<char>(read);
+                } else {
+                    Flush();
+                }
+                break;
+            default:
+                builder += static_cast<char>(read);
+                break;
+            }
+        }
+        Flush();
+    }
+};
+
+struct HtmlParser {
+
+    std::vector<HtmlLexToken> &tokens;
+    size_t index = 0;
+    HtmlParser(std::vector<HtmlLexToken> &tokens) : tokens(tokens) {}
+
+    bool IsSymbol(std::string_view type) {
+        if (Done())
+            return false;
+        auto &obj = Peak();
+        if (obj.type != HtmlLexTokenType::SYMBOL)
+            return false;
+
+        if (obj.text != type)
+            return false;
+        index++;
+        return true;
+    }
+
+    bool Done() { return index >= tokens.size(); }
+
+    HtmlLexToken &Read() { return tokens[index++]; }
+    HtmlLexToken &Peak() { return tokens[index]; }
+
+    void Parse(std::string_view name, std::shared_ptr<HtmlNode> &node,
+               bool root = false) {
+        while (!Done()) {
+            auto &curToken = Peak();
+            switch (curToken.type) {
+            case HtmlLexTokenType::TEXT: {
+                Read();
+                node->children.push_back(HtmlNode::FromText(
+                    Http::HttpUtils::HtmlDecode(curToken.text)));
+            } break;
+            case HtmlLexTokenType::SYMBOL: {
+                if (curToken.text == "<") {
+                    Read();
+                    if (Done()) {
+                        return;
+                    }
+                    auto &val = Peak();
+                    if (val.type == HtmlLexTokenType::TEXT) {
+                        Read();
+
+                        std::shared_ptr<HtmlNode> newNode =
+                            std::make_shared<HtmlNode>();
+                        newNode->isText = false;
+                        newNode->text_or_tag = val.text;
+
+                        while (!Done()) {
+                            auto &k = Peak();
+
+                            if (k.type == HtmlLexTokenType::TEXT) {
+                                Read();
+                                if (IsSymbol("=")) {
+                                    if (!Done()) {
+                                        auto &v = Peak();
+
+                                        if (v.type ==
+                                            HtmlLexTokenType::STRING) {
+                                            Read();
+                                            newNode->attributes.emplace_back(
+                                                k.text,
+                                                Http::HttpUtils::HtmlDecode(
+                                                    v.text));
+                                            continue;
+                                        }
+                                    }
+                                }
+                                newNode->attributes.emplace_back(k.text,
+                                                                 std::nullopt);
+
+                                continue;
+                            }
+
+                            if (k.type == HtmlLexTokenType::SYMBOL &&
+                                (k.text == ">" || k.text == "/>"))
+                                break;
+                        }
+                        if (!IsSymbol("/>")) {
+                            IsSymbol(">");
+                            if (html_nodes_with_no_body.count(val.text) == 0)
+                                Parse(val.text, newNode);
+                        }
+
+                        node->children.push_back(newNode);
+                    }
+                } else if (curToken.text == "</") {
+                    Read();
+                    if (Done()) {
+                        node->children.push_back(HtmlNode::FromText("</"));
+                        return;
+                    }
+                    auto &val = Peak();
+                    Read();
+                    IsSymbol(">");
+
+                    if (val.text == name && !root)
+                        return;
+                }
+            } break;
+            }
+        }
+    }
+
+    std::shared_ptr<HtmlNode> Parse() {
+        std::shared_ptr<HtmlNode> node = std::make_shared<HtmlNode>();
+        node->isText = false;
+        node->text_or_tag = ":root";
+        Parse(":root", node, true);
+        return node;
+    }
+};
+
+std::shared_ptr<HtmlNode>
+Parse(std::shared_ptr<TextStreams::TextReader> reader) {
+    std::vector<HtmlLexToken> tokens;
+
+    HtmlLexer lexer(reader, tokens);
+
+    lexer.Lex();
+
+    HtmlParser parser(tokens);
+
+    return parser.Parse();
+}
+
+} // namespace Tesses::Framework::Serialization::Html