html.cpp

Go to the documentation of this file.

 
/*******************************************************************************
 * Copyright (c) 2021, Jan Koester jan.koester@gmx.net
 * All rights reserved.
 *
 * Redistribution and use in source and binary forms, with or without
 * modification, are permitted provided that the following conditions are met:
 * Redistributions of source code must retain the above copyright
 *      notice, this list of conditions and the following disclaimer.
 * Redistributions in binary form must reproduce the above copyright
 *      notice, this list of conditions and the following disclaimer in the
 *      documentation and/or other materials provided with the distribution.
 * Neither the name of the <organization> nor the
 *      names of its contributors may be used to endorse or promote products
 *      derived from this software without specific prior written permission.
 *
 * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" AND
 * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
 * WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
 * DISCLAIMED. IN NO EVENT SHALL <COPYRIGHT HOLDER> BE LIABLE FOR ANY
 * DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
 * (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
 * LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND
 * ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
 * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
 * SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
 *******************************************************************************/
 
#include <iostream>
#include <cstdarg>
#include <compare>
#include <string_view>
#include <array>
#include <algorithm>
#include <fstream>
 
#include "utils.h"
#include "html.h"
#include "config.h"
#include "encode.h"
#include <assert.h>
 
 
#define HTMLTAG_OPEN '<'
#define HTMLTAG_TERMINATE '/'
#define HTMLTAG_CLOSE '>'
#define HTMLTAG_COMMENT '!'
namespace libhtmlpp {
 
    const std::array<std::string_view,100> ContainerTypes{{
        "a",
        "abbr",
        "address",
        "article",
        "aside",
        "audio",
        "b",
        "bdi",
        "bdo",
        "blockquote",
        "body",
        "button",
        "canvas",
        "caption",
        "cite",
        "code",
        "colgroup",
        "data",
        "datalist",
        "dd",
        "del",
        "details",
        "dfn",
        "dialog",
        "div",
        "dl",
        "dt",
        "em",
        "fieldset",
        "figcaption",
        "figure",
        "footer",
        "form",
        "frame",
        "frameset",
        "h1",
        "h2",
        "h3",
        "h4",
        "h5",
        "h6",
        "head",
        "header",
        "hgroup",
        "html",
        "i",
        "iframe",
        "ins",
        "kbd",
        "label",
        "legend",
        "li",
        "main",
        "map",
        "mark",
        "menu",
        "meter",
        "nav",
        "noscript",
        "object",
        "ol",
        "optgroup",
        "option",
        "output",
        "p",
        "picture",
        "pre",
        "progress",
        "q",
        "rp",
        "rt",
        "ruby",
        "s",
        "samp",
        "search",
        "section",
        "select",
        "small",
        "span",
        "strong",
        "style",
        "sub",
        "summary",
        "sup",
        "svg",
        "table",
        "tbody",
        "td",
        "template",
        "textarea",
        "tfoot",
        "th",
        "thead",
        "time",
        "title",
        "tr",
        "u",
        "ul",
        "var",
        "video"
    }};
 
    class DocElements {
    public:
        std::unique_ptr<Element>         element;
        bool                                            terminator;
        std::unique_ptr<DocElements> nextel;
        class DocElements*                   prevel;
 
        DocElements() {
            nextel = nullptr;
            prevel = nullptr;
            element = nullptr;
            terminator = false;
        }
 
        ~DocElements() {
            auto cur = std::move(nextel);
            while (cur) {
                cur = std::move(cur->nextel);
            }
        }
    };
};
 
libhtmlpp::HtmlString::HtmlString(char str) : HtmlString(){
    // Route through the member push_back() rather than pushing onto _Data
    // directly -- that's the one place the trailing '\0' sentinel (see
    // size()'s doc comment) and the NUL-guard are maintained. Pushing raw
    // left _Data without a sentinel at all, so c_str() returned a
    // one-element buffer with no NUL terminator -- undefined behavior for
    // any caller that treats it as a C string -- and length() (before it
    // started delegating to size()) silently reported 0 for a real
    // 1-character string.
    push_back(str);
}
 
libhtmlpp::HtmlString::HtmlString(const std::string& str) : HtmlString(){
    if(str.empty())
        return;
 
    if (!_Data.empty() && _Data.back() == '\0') {
        _Data.pop_back();
    }
 
   for(auto i = str.begin(); i!=str.end(); ++i){
       if(*i=='\0')
           break;
       _Data.push_back(*i);
   }
 
    if (_Data.empty() || _Data.back() != '\0') {
        _Data.push_back('\0');
    }
}
 
libhtmlpp::HtmlString::~HtmlString(){
}
 
libhtmlpp::HtmlString::HtmlString(const libhtmlpp::HtmlString& str) : HtmlString() {
    std::copy(str._Data.begin(),str._Data.end(),std::insert_iterator<std::vector<char>>(_Data,_Data.begin()));
}
 
void libhtmlpp::HtmlString::push_back(const char src){
    if(!src)
        return;
 
    if (!_Data.empty() && _Data.back() == '\0') {
        _Data.pop_back();
    }
    _Data.push_back(src);
 
    _Data.push_back('\0');
}
 
void libhtmlpp::HtmlString::append(const std::string& src) {
    if(src.empty())
        return;
 
    if (!_Data.empty() && _Data.back() == '\0') {
        _Data.pop_back();
    }
 
   for(auto i = src.begin(); i!=src.end(); ++i){
       if(*i=='\0')
           break;
       _Data.push_back(*i);
   }
 
    if (_Data.empty() || _Data.back() != '\0') {
        _Data.push_back('\0');
    }
}
 
void libhtmlpp::HtmlString::append(libhtmlpp::HtmlString& hstring) {
    std::copy(hstring._Data.begin(),hstring._Data.end(),std::back_inserter(_Data));
}
 
void libhtmlpp::HtmlString::insert(size_t pos, char src){
    _Data.at(pos)=src;
}
 
void libhtmlpp::HtmlString::clear(){
    _rootEl.reset();
    _Data.clear();
}
 
bool libhtmlpp::HtmlString::empty(){
    return _Data.empty();
}
 
 
libhtmlpp::HtmlString &libhtmlpp::HtmlString::operator+=(const std::string &src){
    append(src);
    return *this;
}
 
libhtmlpp::HtmlString & libhtmlpp::HtmlString::operator+=(libhtmlpp::HtmlString& hstring){
    append(hstring);
    return *this;
}
 
libhtmlpp::HtmlString & libhtmlpp::HtmlString::operator=(const std::string &src){
    clear();
    append(src);
    return *this;
}
 
libhtmlpp::HtmlString& libhtmlpp::HtmlString::operator=(const libhtmlpp::HtmlString& src){
    clear();
    std::copy(src._Data.begin(),src._Data.end(),std::insert_iterator<std::vector<char>>(_Data,_Data.begin()));
    return *this;
}
 
char libhtmlpp::HtmlString::operator[](size_t pos) const{
    return _Data.at(pos);
}
 
libhtmlpp::HtmlString& libhtmlpp::HtmlString::operator<<(const char* src) {
    append(src);
    return *this;
}
 
libhtmlpp::HtmlString& libhtmlpp::HtmlString::operator<<(const std::string &src) {
    append(src);
    return *this;
}
 
libhtmlpp::HtmlString& libhtmlpp::HtmlString::operator<<(HtmlString src) {
    if(src._Data.data())
        std::copy(src._Data.begin(),src._Data.end(),std::back_inserter(_Data));
    return *this;
}
 
libhtmlpp::HtmlString& libhtmlpp::HtmlString::operator<<(int src) {
    char buf[255];
    snprintf(buf, 255, "%d", src);
    append(buf);
    return *this;
}
 
libhtmlpp::HtmlString& libhtmlpp::HtmlString::operator<<(size_t src) {
    char buf[255];
    snprintf(buf, 255, "%zu", src);
    append(buf);
    return *this;
}
 
libhtmlpp::HtmlString& libhtmlpp::HtmlString::operator<<(char src) {
    push_back(src);
    return *this;
}
 
const char* libhtmlpp::HtmlString::operator*(){
    return _Data.data();
}
 
size_t libhtmlpp::HtmlString::length() const{
    // Pure synonym for size() (matching std::string's own size()/length()
    // convention) -- delegate instead of duplicating the sentinel-aware
    // logic a second time, which is what let this drift out of sync with
    // size() in the first place (this used to unconditionally subtract 1,
    // silently under-counting by one byte -- and never NUL-guarding --
    // whenever the trailing '\0' sentinel wasn't actually present).
    return size();
}
 
size_t libhtmlpp::HtmlString::size() const{
    // append()/push_back()/etc. maintain a trailing '\0' sentinel in _Data so
    // c_str() stays valid between calls (pop it, write new content, push it
    // back) — that byte is a private bookkeeping detail, not real content,
    // so it must not be counted here. Without this, every consumer that
    // trusts size()/str() to describe the actual string (e.g. building a
    // larger buffer by concatenating multiple HtmlString results) ends up
    // with a genuine embedded NUL baked into otherwise-clean text, which
    // then silently truncates any later strlen()-based use of that buffer.
    if (!_Data.empty() && _Data.back() == '\0')
        return _Data.size() - 1;
    return _Data.size();
}
 
const std::string libhtmlpp::HtmlString::str() const{
    if(_Data.data())
        return std::string(_Data.begin(), _Data.begin() + static_cast<long>(size()));
    return "";
}
 
const char *libhtmlpp::HtmlString::c_str() const{
    return _Data.data();
}
 
const std::vector<char>& libhtmlpp::HtmlString::data() const{
    return _Data;
}
 
 
libhtmlpp::Element &libhtmlpp::HtmlString::parse() {
    HTMLException excp;
    _buildTree();
    return *_rootEl;
}
 
void libhtmlpp::HtmlString::_buildtreenode(
    DocElements *firstel,
    libhtmlpp::DocElements *lastel,
    std::unique_ptr<Element> &html)
{
    if (!firstel) {
        HTMLException excp;
        excp[HTMLException::Error] << "No start Element!";
        throw excp;
    }
 
    struct Frame {
        DocElements *open;              // Opener-DocElement (Start-Tag)
        DocElements *close;             // passender Terminator-DocElement (End-Tag)
        const DocElements *outer_end;   // Grenze der aktuellen Ebene
        Element *outer_prev_el;         // letztes bereits eingebautes Geschwister der äußeren Ebene
    };
    std::stack<Frame> stack;
 
    DocElements *start = firstel;
    const DocElements *end = lastel;    // nullptr bedeutet: bis Ketten-Ende
 
    Element *prev_el_in_tree = nullptr; // zuletzt in den Baum eingebautes Element
 
    auto checkContainer = [&](const std::string &tag) {
        for (size_t i = 0; i < ContainerTypes.size(); ++i) {
            if (tag == ContainerTypes[i]) return true;
        }
        return false;
    };
 
    // Leere DocElements überspringen (z. B. Kommentare/Text, die nicht als element abgebildet sind)
    auto skip_empty = [](DocElements *cur, const DocElements *stop) -> DocElements* {
        while (cur && cur != stop && (!cur->element)) {
            cur = cur->nextel.get();
        }
        return cur;
    };
 
    // Finde zum gegebenen Start-Tag dessen passenden Terminator in [open->nextel, bound).
    auto find_terminator = [&skip_empty, checkContainer](DocElements *open, const DocElements *bound) -> DocElements* {
        if (!open || !open->element || open->terminator ||
            open->element->getType() != HtmlEl) return nullptr;
 
        const std::string &tag = static_cast<HtmlElement*>(open->element.get())->getTagname();
        int nest = 0;
        DocElements *cur = open->nextel.get();
 
        while (cur && cur != bound) {
            cur = skip_empty(cur, bound);
            if (!cur || cur == bound) break;
 
            if (cur->element && cur->element->getType() == HtmlEl) {
                const std::string &curtag = static_cast<HtmlElement*>(cur->element.get())->getTagname();
                if (curtag == tag) {
                    if (cur->terminator) {
                        if (nest == 0) return cur; // passendes End-Tag gefunden
                        --nest;
                    } else {
                        ++nest;
                    }
                }
            }
            cur = cur->nextel.get();
        }
 
        // Wenn ein Container nicht geschlossen wurde: Warnung ignorieren oder als einfaches Tag behandeln
        if (checkContainer(tag)) {
            // Exception entfernt für nachsichtigeres Parsing
            // return nullptr;
        }
        return nullptr;
    };
 
    for (;;) {
        // bis zum nächsten sinnvollen DocElement laufen
        start = skip_empty(start, end);
 
        // Terminator-Knoten als eigenständige Nodes überspringen
        if (start && start != end && start->terminator) {
            start = start->nextel.get();
            continue;
        }
 
        // Ende der aktuellen Ebene erreicht?
        if (!start || start == end) {
            if (stack.empty()) {
                // Ganz oben: Root setzen (falls vorhanden)
                if (firstel->element) {
                    html = std::move(firstel->element);
                }
                return;
            }
 
            // Frame schließen: Kinderbereich [open->nextel, close) einsammeln
            Frame fr = stack.top(); stack.pop();
            HtmlElement *opener_el = static_cast<HtmlElement*>(fr.open->element.get());
 
            // Alle Kinder zwischen open und close verketten
            Element* last_child_in_chain = nullptr;
            {
                DocElements* cur = fr.open->nextel.get();
                // bis zum ersten brauchbaren Kind
                while (cur && cur != fr.close && (!cur->element || cur->terminator)) {
                    cur = cur->nextel.get();
                }
 
                // alle nicht-leeren, nicht-Terminierer bis vor close anbinden
                while (cur && cur != fr.close) {
                    if (cur->element && !cur->terminator) {
                        if (!opener_el->_childElement) {
                            opener_el->_childElement = std::move(cur->element);
                            last_child_in_chain = opener_el->_childElement.get();
                        } else {
                            last_child_in_chain->_nextElement = std::move(cur->element);
                            // _prev (falls genutzt) setzen
                            last_child_in_chain->_nextElement->_prevElement = last_child_in_chain;
                            last_child_in_chain = last_child_in_chain->_nextElement.get();
                        }
                    }
                    cur = cur->nextel.get();
                    // leere/terminator Knoten überspringen
                    while (cur && cur != fr.close && (!cur->element || cur->terminator)) {
                        cur = cur->nextel.get();
                    }
                }
            }
 
            // dieses Container-Element ist nun das "aktuelle" in der äußeren Ebene
            prev_el_in_tree = opener_el;
 
            // Wenn es bereits ein vorheriges Geschwister in der äußeren Ebene gibt: verketten
            if (fr.outer_prev_el) {
                prev_el_in_tree->_prevElement = fr.outer_prev_el;
                fr.outer_prev_el->_nextElement = std::move(fr.open->element);
                prev_el_in_tree = fr.outer_prev_el->_nextElement.get();
            }
 
            // für die äußere Ebene fortsetzen
            prev_el_in_tree = opener_el;
            start = (fr.close ? fr.close->nextel.get() : nullptr);
            end   = fr.outer_end;
 
            continue;
        }
 
        // Start-Tag eines HTML-Elements: passenden Terminator suchen → in den Stack tauchen
        if (start->element && !start->terminator && start->element->getType() == HtmlEl) {
            if (DocElements *close = find_terminator(start, end)) {
                // neuen Rahmen für diesen Container aufmachen
                stack.push(Frame{start, close, end, prev_el_in_tree});
 
                // wir wechseln in die innere Ebene: prev zurücksetzen
                prev_el_in_tree = nullptr;
                start           = start->nextel.get();
                end             = close;
                continue;
            }
        }
 
        // "normales" Element (kein Container mit eigenem Terminatorbereich):
        if (start->element && !start->terminator) {
            Element *current_el = start->element.get();
 
            if (prev_el_in_tree) {
                current_el->_prevElement = prev_el_in_tree;
                prev_el_in_tree->_nextElement = std::move(start->element);
                prev_el_in_tree = prev_el_in_tree->_nextElement.get();
            } else {
                prev_el_in_tree = current_el;
            }
        }
 
        // weiter zum nächsten DocElement
        start = start->nextel.get();
    }
}
 
void libhtmlpp::HtmlString::_buildTree() {
    DocElements* lastEl = nullptr;
    std::unique_ptr<DocElements> firstEl = nullptr;
 
    auto is_ws = [](unsigned char ch) -> bool {
        // space, \t, \n, \r
        return ch == ' ' || ch == '\t' || ch == '\n' || ch == '\r';
    };
 
    auto ascii_tolower = [](unsigned char c) -> unsigned char {
        return (c >= 'A' && c <= 'Z') ? static_cast<unsigned char>(c + 32) : c;
    };
 
    auto starts_with_ci = [&](const char* s, const char* e, const char* k) -> bool {
        const size_t klen = std::char_traits<char>::length(k);
        if (static_cast<size_t>(e - s) < klen) return false;
        for (size_t i = 0; i < klen; ++i) {
            unsigned char a = static_cast<unsigned char>(s[i]);
            unsigned char b = static_cast<unsigned char>(k[i]);
            if (ascii_tolower(a) != ascii_tolower(b)) return false;
        }
        return true;
    };
 
    auto add_element_node = [&](DocElements** last) {
        if (!firstEl) {
            firstEl = std::make_unique<DocElements>();
            *last   = firstEl.get();
        } else {
            (*last)->nextel        = std::make_unique<DocElements>();
            (*last)->nextel->prevel = (*last);
            *last                  = (*last)->nextel.get();
        }
    };
 
    const char* const base = _Data.data();
    const size_t n        = _Data.size();
    const char* const end = base + n;
 
    const char* p = base;
 
    while (p < end) {
        const char* wsStart = p;
        while (p < end && is_ws(static_cast<unsigned char>(*p))) ++p;
        if (p >= end) break;
 
        if (*p == HTMLTAG_OPEN) { // '<'
            // A whitespace-only run directly between two tags (e.g.
            // "</span> <a>", "</a> <a>") still separates whatever inline
            // content sits on either side of it -- collapse it to a single
            // space instead of silently discarding it, or adjacent inline
            // elements lose the space that keeps their rendered text apart.
            // Leading whitespace before the very first tag in the document
            // is not meaningful the same way, so it's still dropped.
            if (p > wsStart && firstEl) {
                add_element_node(&lastEl);
                auto ws = std::make_unique<TextElement>();
                static_cast<TextElement*>(ws.get())->_Text.push_back(' ');
                lastEl->element = std::move(ws);
                lastEl->terminator = false;
            }
 
            const char* const remain_end = end;
            const size_t remain = static_cast<size_t>(remain_end - p);
 
            if (remain >= 2) {
                const unsigned char c1 = ascii_tolower(static_cast<unsigned char>(p[1]));
 
                if (p[1] == '!') {
                    // <!-- ... -->
                    if (starts_with_ci(p, end, "<!--")) {
                        add_element_node(&lastEl);
                        size_t i = static_cast<size_t>(p - base);
                        i = CommentElement::parseElement(_Data, lastEl->element, i, lastEl->terminator);
                        p = base + i;
                        continue;
                    }
                    if (starts_with_ci(p, end, "<!doctype")) {
                        const char* close_tag = p;
                        while (close_tag < end && *close_tag != '>') {
                            ++close_tag;
                        }
                        if (close_tag < end) {
                            p = close_tag + 1;
                        } else {
                            p = end;
                        }
                        continue;
                    }
                } else if (c1 == 's') {
                    if (starts_with_ci(p, end, "<script")) {
                        add_element_node(&lastEl);
                        size_t i = static_cast<size_t>(p - base);
                        i = ScriptElement::parseElement(_Data, lastEl->element, i, lastEl->terminator);
                        p = base + i;
                        continue;
                    }
                    if (starts_with_ci(p, end, "<svg")) {
                        add_element_node(&lastEl);
                        size_t i = static_cast<size_t>(p - base);
                        i = SvgElement::parseElement(_Data, lastEl->element, i, lastEl->terminator);
                        p = base + i;
                        continue;
                    }
                    if (starts_with_ci(p, end, "<style")) {
                        // Same raw-text rationale as <script> above: CSS
                        // content can contain '<'/'>' (child-combinator
                        // selectors, stray markup pasted into a comment,
                        // duplicate/unclosed <style> tags from a page
                        // builder concatenating snippets, ...) that the
                        // ordinary tag-tokenizing path below would
                        // misinterpret as nested markup, corrupting
                        // everything parsed after it.
                        add_element_node(&lastEl);
                        size_t i = static_cast<size_t>(p - base);
                        i = HtmlElement::parseStyleElement(_Data, lastEl->element, i, lastEl->terminator);
                        p = base + i;
                        continue;
                    }
                } else if (c1 == 't') {
                    if (starts_with_ci(p, end, "<textarea")) {
                        add_element_node(&lastEl);
                        size_t i = static_cast<size_t>(p - base);
                        i = TextArea::parseElement(_Data, lastEl->element, i, lastEl->terminator);
                        p = base + i;
                        continue;
                    }
                }
            }
 
            {
                add_element_node(&lastEl);
                size_t i = static_cast<size_t>(p - base);
                i = HtmlElement::parseElement(_Data, lastEl->element, i, lastEl->terminator);
                p = base + i;
            }
        } else {
            // Start from wsStart, not p: any whitespace just skipped above
            // is genuine leading whitespace of this text run (it wasn't
            // followed by '<', so it's not an inter-tag separator handled
            // above), and TextElement::parseElement collapses it to a
            // single leading space itself -- re-skipping it here would
            // drop that space entirely.
            add_element_node(&lastEl);
            size_t i = static_cast<size_t>(wsStart - base);
            i = TextElement::parseElement(_Data, lastEl->element, i, lastEl->terminator);
            p = base + i;
        }
    }
 
    _buildtreenode(firstEl.get(), nullptr, _rootEl);
    // _buildtreenode's own linking logic is intricate enough (see its own
    // comments) that threading parent-assignment through it directly risks
    // a subtle new bug for marginal benefit -- this single pass over the
    // now-correctly-linked tree is simple to get right by inspection
    // instead.
    if(_rootEl) HtmlElement::_assignParentPointers(_rootEl.get(), nullptr);
}
 
std::ostream& operator<<(std::ostream& os, const libhtmlpp::HtmlString& p) {
    os << p.str();
    return os;
}
 
void libhtmlpp::HtmlEncode(const std::string &input, std::string &output){
    size_t ilen=input.length();
    for(size_t i=0; i<ilen; ++i){
        size_t ii=0;
        bool changed=false;
        while(HtmlSigns[ii][0]){
            if(input[i]==HtmlSigns[ii][0][0]){
                output+=HtmlSigns[ii][1];
                changed=true;
            }
            ++ii;
        }
        if(!changed)
            output.push_back(input[i]);
    }
}
 
void libhtmlpp::HtmlDecode(const std::string &input,std::string &output){
    size_t ilen=input.length();
    for(size_t i=0; i<ilen; ++i){
        size_t ii=0;
        bool changed=false;
        while(HtmlSigns[ii][0]){
            if(input.compare(i,strlen(HtmlSigns[ii][1]),HtmlSigns[ii][1]) == 0){
                output += HtmlSigns[ii][0];
                changed=true;
            }
            ++ii;
        }
        if(!changed)
            output += input[i];
    }
}
 
void libhtmlpp::HtmlDecode(const std::string &input,HtmlString &output){
    std::string tmp;
    HtmlDecode(input,tmp);
    output << tmp;
    output.parse();
}
 
libhtmlpp::HtmlElement::HtmlElement(const std::string &tagname) : HtmlElement(){
    _TagName.clear();
    std::copy(tagname.begin(),tagname.end(),std::back_inserter(_TagName));
}
 
libhtmlpp::HtmlElement::HtmlElement() : Element() {
    _childElement=nullptr;
    _firstAttr=nullptr;
    _lastAttr=nullptr;
}
 
libhtmlpp::HtmlElement::HtmlElement(const libhtmlpp::HtmlElement& hel) : HtmlElement(){
    _copy(this,&hel);
}
 
libhtmlpp::HtmlElement::HtmlElement(const libhtmlpp::HtmlElement* hel) : HtmlElement(){
    _copy(this,hel);
}
 
libhtmlpp::HtmlElement::~HtmlElement(){
}
 
int libhtmlpp::Element::getType() const{
    return -1;
}
 
void libhtmlpp::HtmlElement::setTagname(const std::string &name){
    _TagName.clear();
    std::copy(name.begin(),name.begin()+name.length(),std::back_inserter(_TagName));
}
 
const std::string libhtmlpp::HtmlElement::getTagname() const{
    if(_TagName.empty())
        return "";
    return std::string(_TagName.begin(),_TagName.end());
}
 
void libhtmlpp::HtmlElement::_assignParentPointers(Element* node, Element* parent){
    while(node){
        node->_parentElement = parent;
        // Only plain HtmlEl nodes use this (base) _childElement for real
        // children via insertChild/appendChild -- ScriptElement/SvgElement/
        // TextArea each shadow their own separate _childElement instead
        // (and don't support insertChild/appendChild at all, both deleted),
        // so descending through the base pointer for those types would
        // read the wrong field entirely.
        if(node->getType()==HtmlEl){
            HtmlElement *hel = static_cast<HtmlElement*>(node);
            if(hel->_childElement)
                _assignParentPointers(hel->_childElement.get(), node);
        }
        node = node->_nextElement.get();
    }
}
 
void libhtmlpp::HtmlElement::insertChild(const libhtmlpp::Element* el){
    if(_childElement){
        remove(_childElement.get());
    }
 
    switch(el->getType()){
        case HtmlEl:
            _childElement=std::make_unique<HtmlElement>();
            break;
        case TextEl:
            _childElement=std::make_unique<TextElement>();
            break;
        case CommentEl:
            _childElement=std::make_unique<CommentElement>();
            break;
        case ScriptEL:
            _childElement=std::make_unique<ScriptElement>();
            break;
        case SvgEL:
            _childElement=std::make_unique<SvgElement>();
            break;
        default:
            HTMLException ex;
            ex[HTMLException::Critical] << "appendChild: Unknown html element found: "<< el->getType() << " !";
            throw ex;
    }
    _copy(_childElement.get(),el);
    // _copy re-parents the copied subtree's own descendants (relative to
    // _childElement.get()) but deliberately never touches _childElement's
    // OWN parent -- that's this call site's job.
    _childElement->_parentElement = this;
}
 
void libhtmlpp::HtmlElement::insertChild(const Element& el){
    insertChild(&el);
}
 
void libhtmlpp::HtmlElement::appendChild(const libhtmlpp::Element* el){
    if(!el)
        return;
    if(_childElement){
        Element *prev=nullptr;
 
        for(Element *curel=_childElement.get(); curel; curel=curel->nextElement()){
            prev=curel;
        }
 
        switch(el->getType()){
            case HtmlEl:
                prev->_nextElement=std::make_unique<HtmlElement>();
                break;
            case TextEl:
                prev->_nextElement=std::make_unique<TextElement>();
                break;
            case CommentEl:
                prev->_nextElement=std::make_unique<CommentElement>();
                break;
            case ScriptEL:
                prev->_nextElement=std::make_unique<ScriptElement>();
                break;
            case SvgEL:
                prev->_nextElement=std::make_unique<SvgElement>();
                break;
            default:
                HTMLException ex;
                ex[HTMLException::Critical] << "appendChild: Unknown html element found: "<< el->getType() << " !";
                throw ex;
        }
 
        _copy(prev->_nextElement.get(),el);
 
        if(prev->_nextElement){
            prev->_nextElement->_prevElement=prev;
            // Siblings share the same parent -- this, not prev.
            prev->_nextElement->_parentElement=this;
        }
    }else{
        insertChild(el);
    }
}
 
void libhtmlpp::HtmlElement::appendChild(const Element& el){
    appendChild(&el);
}
 
 
bool libhtmlpp::HtmlElement::operator==(const HtmlElement *hel){
    if(!hel)
        return false;
    if( _TagName.size() != hel->_TagName.size())
        return false;
    if(std::equal(_TagName.begin(),_TagName.end(),hel->_TagName.begin()))
        return true;
    return false;
}
 
bool libhtmlpp::HtmlElement::operator==(const HtmlElement &hel){
    if(_TagName.size() != hel._TagName.size())
        return false;
    if(std::equal(_TagName.begin(),_TagName.end(),hel._TagName.begin()))
        return true;
    return false;
}
 
libhtmlpp::HtmlElement & libhtmlpp::HtmlElement::operator=(const libhtmlpp::HtmlElement& hel){
    _copy(this,&hel);
    return *this;
}
 
libhtmlpp::HtmlElement & libhtmlpp::HtmlElement::operator=(const libhtmlpp::HtmlElement* hel){
    _copy(this,hel);
    return *this;
}
 
void libhtmlpp::HtmlElement::remove(libhtmlpp::Element* el){
    // Previously a DFS over the whole subtree via an explicit stack/goto,
    // searching for whoever owns `el` -- with _parentElement, that lookup
    // is O(1) instead, and the simpler logic below replaces several bugs
    // that walk found in that DFS: a null-pointer dereference right after
    // finding `el` via ordinary sibling advancement (the old code set
    // `cur=nullptr` on a match and then unconditionally dereferenced it on
    // the very next line); `el` being silently walked past, never unlinked,
    // when reached by diving into a `_childElement` (the old code never
    // re-checked the dived-into node against `el`); and removing a parent's
    // first child never repointing `parent->_childElement`, which quietly
    // discarded the rest of that sibling chain.
    if(!el) return;
 
    Element *parent = el->_parentElement;
    Element *prevSibling = el->_prevElement;
    // Whoever currently owns `el` via a unique_ptr (parent->_childElement,
    // or a previous sibling's _nextElement) is about to be reassigned away
    // from `el` below, which destroys `el` immediately as part of that
    // assignment (reassigning a unique_ptr destroys whatever it used to
    // own) -- so everything needed from `el` must be captured first.
    // release() (not move/get()) detaches el's own next-sibling chain
    // without destroying anything, unlike move-assigning it while it's
    // still reachable through `el`.
    std::unique_ptr<Element> elsNext(el->_nextElement.release());
 
    if(parent && parent->getType()==HtmlEl &&
       static_cast<HtmlElement*>(parent)->_childElement.get()==el){
        if(elsNext) elsNext->_prevElement = nullptr;
        static_cast<HtmlElement*>(parent)->_childElement = std::move(elsNext); // destroys el
    } else if(prevSibling){
        if(elsNext) elsNext->_prevElement = prevSibling;
        prevSibling->_nextElement = std::move(elsNext); // destroys el
    }
    // else: el has neither a parent nor a previous sibling (e.g. a
    // rootless standalone node) -- nothing owns it via a reassignable
    // unique_ptr, so it's left unlinked-from but not destroyed.
 
    // el must not be touched below this point in the two branches above --
    // it no longer exists.
}
 
void libhtmlpp::HtmlElement::_serialelize(const std::vector<char>& in, bool preserveAttrCase) {
    _TagName.clear();
 
    auto is_space = [](unsigned char c) -> bool {
        return c == ' ' || c == '\t' || c == '\n' || c == '\r';
    };
    auto tolower_ascii = [](unsigned char c) -> unsigned char {
        return (c >= 'A' && c <= 'Z') ? static_cast<unsigned char>(c + 32) : c;
    };
 
    size_t i = 0, n = in.size();
 
    if (i < n && in[i] == '<') ++i;
    while (i < n && is_space(static_cast<unsigned char>(in[i]))) ++i;
 
    bool end_tag = false;
    if (i < n && in[i] == '/') {
        end_tag = true;
        ++i;
        while (i < n && is_space(static_cast<unsigned char>(in[i]))) ++i;
    }
 
    size_t r = n;
    while (r > i && is_space(static_cast<unsigned char>(in[r - 1]))) --r;
    if (r > i && in[r - 1] == '>') --r; // ignore '>' if present
    while (r > i && is_space(static_cast<unsigned char>(in[r - 1]))) --r;
 
    if (i >= r) {
        HTMLException excp;
        throw excp[HTMLException::Critical] << "no tag in element found!";
    }
 
    const size_t name_start = i;
    while (i < r) {
        unsigned char c = static_cast<unsigned char>(in[i]);
        if (is_space(c) || c == '/' || c == '>') break;
        ++i;
    }
    const size_t name_end = i;
    if (name_start == name_end) {
        HTMLException excp;
        throw excp[HTMLException::Critical] << "no tag in element found!";
    }
 
    _TagName.assign(in.begin() + name_start, in.begin() + name_end);
    for (char& ch : _TagName) ch = static_cast<char>(tolower_ascii(static_cast<unsigned char>(ch)));
 
    if (end_tag) {
        return;
    }
 
    while (i < r) {
        while (i < r && is_space(static_cast<unsigned char>(in[i]))) ++i;
        if (i >= r) break;
 
        if (in[i] == '/') {
            ++i;
            while (i < r && is_space(static_cast<unsigned char>(in[i]))) ++i;
            break;
        }
 
        const size_t kstart = i;
        while (i < r) {
            unsigned char c = static_cast<unsigned char>(in[i]);
            if (is_space(c) || c == '=' || c == '/' || c == '>') break;
            ++i;
        }
        const size_t kend = i;
        if (kstart == kend) {
            ++i;
            continue;
        }
 
        std::string key(in.begin() + kstart, in.begin() + kend);
        if (!preserveAttrCase) {
            for (char& ch : key) ch = static_cast<char>(tolower_ascii(static_cast<unsigned char>(ch)));
        }
 
        while (i < r && is_space(static_cast<unsigned char>(in[i]))) ++i;
 
        std::string val;
 
        if (i < r && in[i] == '=') {
            ++i;
            while (i < r && is_space(static_cast<unsigned char>(in[i]))) ++i;
 
            if (i < r && (in[i] == '"' || in[i] == '\'')) {
                char quote = in[i++];
                const size_t vstart = i;
                while (i < r && in[i] != quote) ++i;
                const size_t vend = i;
                val.assign(in.begin() + vstart, in.begin() + vend);
                if (i < r && in[i] == quote) ++i;
            } else {
                const size_t vstart = i;
                while (i < r) {
                    unsigned char c = static_cast<unsigned char>(in[i]);
                    if (is_space(c) || c == '/' || c == '>') break;
                    ++i;
                }
                const size_t vend = i;
                val.assign(in.begin() + vstart, in.begin() + vend);
            }
        } else {
            val.clear();
        }
 
        setAttribute(key, val);
    }
}
 
 
size_t libhtmlpp::HtmlElement::parseElement(
    const std::vector<char>& in,
    std::unique_ptr<libhtmlpp::Element>& el,
    size_t start,
    bool& termination
){
    el = std::make_unique<HtmlElement>();
    termination = false;
 
    size_t i = start;
    if (i >= in.size() || in[i] != HTMLTAG_OPEN) return i;
 
    ++i;
 
    while (i < in.size() && std::isspace(static_cast<unsigned char>(in[i]))) ++i;
 
 
 
    // Quote-aware scan for this tag's own '>' -- a '<'/'>' inside a quoted
    // attribute value (e.g. title="a < b") doesn't end the tag. Critically,
    // an UNQUOTED '<' encountered here means this tag itself was never
    // terminated (a missing '>', e.g. a malformed "</div" straight into the
    // next markup) -- stopping at that '<' instead of scanning past it
    // keeps that next tag intact for the caller to (re-)dispatch on its own
    // merits (e.g. a following <script> still gets ScriptElement's raw-text
    // handling) rather than silently swallowing it as bogus "attribute"
    // content of this broken tag, whose own closing '>' would otherwise
    // wrongly end up terminating THIS one instead.
    size_t close = i;
    bool foundClose = false;
    char quote = 0;
    while (close < in.size()) {
        char c = in[close];
        if (quote) {
            if (c == quote) quote = 0;
        } else if (c == HTMLTAG_CLOSE) { // '>'
            foundClose = true;
            break;
        } else if (c == HTMLTAG_OPEN) { // '<'
            break;
        } else if (c == '"' || c == '\'') {
            quote = c;
        }
        ++close;
    }
 
    size_t k = i;
    while (k < close && std::isspace(static_cast<unsigned char>(in[k]))) ++k;
 
    std::vector<char> tel;
 
    if (k < close && in[k] == HTMLTAG_TERMINATE) { // '/'
        termination = true;
        ++k;
        while (k < close && std::isspace(static_cast<unsigned char>(in[k]))) ++k;
    }
 
    tel.insert(tel.end(), in.begin() + k, in.begin() + close);
 
    reinterpret_cast<HtmlElement*>(el.get())->_serialelize(tel);
 
    return foundClose ? close + 1 : close;
}
 
size_t libhtmlpp::HtmlElement::parseStyleElement(
    const std::vector<char>& in,
    std::unique_ptr<Element>& el,
    size_t start,
    bool& termination
){
    termination = false;
    el = std::make_unique<HtmlElement>("style");
    auto* self = static_cast<HtmlElement*>(el.get());
 
    size_t i = start;
    if (i >= in.size() || in[i] != HTMLTAG_OPEN) {
        return start;
    }
 
    auto iequals = [](char a, char b) {
        return std::tolower(static_cast<unsigned char>(a)) ==
               std::tolower(static_cast<unsigned char>(b));
    };
    auto match_ci = [&](size_t pos, const char* k) -> bool {
        for (size_t j = 0; k[j]; ++j) {
            if (pos + j >= in.size() || !iequals(in[pos + j], k[j])) {
                return false;
            }
        }
        return true;
    };
 
    ++i; // consume '<'
    while (i < in.size() && std::isspace(static_cast<unsigned char>(in[i]))) ++i;
 
    const char* tag_keyword = "style";
    size_t keyword_len = std::char_traits<char>::length(tag_keyword);
 
    if (i + keyword_len >= in.size() || !match_ci(i, tag_keyword)) {
        // Not actually a <style -- skip to the next '>' like the other
        // dedicated parseElement variants do for their own mismatched case.
        while (i < in.size() && in[i] != HTMLTAG_CLOSE) ++i;
        if (i < in.size()) ++i;
        return i;
    }
    i += keyword_len; // consume "style"
 
    // Find the opening tag's own '>' (attributes only -- style's opening
    // tag is ordinary markup, just its content that needs raw-text care).
    while (i < in.size() && in[i] != HTMLTAG_CLOSE) ++i;
 
    if (i > start && i < in.size() && in[i] == HTMLTAG_CLOSE) {
        std::vector<char> raw_tag_data(in.begin() + start, in.begin() + i + 1);
        self->_serialelize(raw_tag_data);
    }
 
    if (i >= in.size() || in[i] != HTMLTAG_CLOSE) {
        // Opening tag itself was never closed (e.g. EOF mid-attribute-list).
        return i;
    }
 
    ++i; // consume '>'
    size_t content_begin = i;
 
    // Raw-text scan for the literal closing sequence: </style -- everything
    // in between, including any '<'/'>' a CSS selector/comment happens to
    // contain, is opaque content, exactly like <script>'s own handling.
    for (; i < in.size(); ++i) {
        if (in[i] == HTMLTAG_OPEN && match_ci(i, "</style")) {
            if (i > content_begin) {
                std::string cssText(in.begin() + content_begin, in.begin() + i);
                TextElement textEl(cssText);
                self->appendChild(&textEl);
            }
 
            size_t closing_tag_end_pos = i + keyword_len + 2; // +2 for '</'
            while (closing_tag_end_pos < in.size() && in[closing_tag_end_pos] != HTMLTAG_CLOSE) {
                ++closing_tag_end_pos;
            }
 
            if (closing_tag_end_pos < in.size() && in[closing_tag_end_pos] == HTMLTAG_CLOSE) {
                return closing_tag_end_pos + 1;
            }
            return closing_tag_end_pos;
        }
    }
 
    // No closing </style> before EOF -- capture whatever's left, same
    // best-effort fallback ScriptElement::parseElement uses.
    if (in.size() > content_begin) {
        std::string cssText(in.begin() + content_begin, in.end());
        TextElement textEl(cssText);
        self->appendChild(&textEl);
    }
    return i;
}
 
namespace libhtmlpp {
 
    void _copy(libhtmlpp::Element *dest,const libhtmlpp::Element *src){
        if(!dest || !src)
            return;
 
        // `dest` itself is reassigned throughout the copy loop below --
        // captured here so the parent-pointer fixup at the end can still
        // find the original top-level destination.
        libhtmlpp::Element* const originalDest = dest;
 
        const libhtmlpp::Element* prev=nullptr;
 
        struct cpyel {
            cpyel(){
                destin = nullptr;
                source = nullptr;
            };
 
            cpyel(const cpyel &src){
                destin=src.destin;
                source=src.source;
            };
 
            ~cpyel(){
            }
 
            libhtmlpp::Element *destin;
            libhtmlpp::Element *source;
        };
 
        std::stack<cpyel> cpylist;
 
        NEWEL:
 
        if(src->getType()==HtmlEl && dest->getType()==HtmlEl){
            ((libhtmlpp::HtmlElement*)dest)->_TagName=(((libhtmlpp::HtmlElement*)src)->_TagName);
            for(libhtmlpp::HtmlElement::Attributes *cattr=((libhtmlpp::HtmlElement*)src)->_firstAttr.get(); cattr; cattr=cattr->_nextAttr.get()){
                ((libhtmlpp::HtmlElement*)dest)->setAttribute(
                    std::string(
                        cattr->_Key.begin(),
                                cattr->_Key.end()
                    ),std::string(
                        cattr->_Value.begin(),
                                  cattr->_Value.end()
                    )
                );
            }
 
            if(((libhtmlpp::HtmlElement*)src)->_childElement){
                switch(((libhtmlpp::HtmlElement*)src)->_childElement->getType()){
                    case HtmlEl:
                        ((libhtmlpp::HtmlElement*)dest)->_childElement=std::make_unique<HtmlElement>();
                        break;
                    case TextEl:
                        ((libhtmlpp::HtmlElement*)dest)->_childElement =std::make_unique<TextElement>();
                        break;
                    case CommentEl:
                        ((libhtmlpp::HtmlElement*)dest)->_childElement = std::make_unique<CommentElement>();
                        break;
                    case ScriptEL:
                        ((libhtmlpp::HtmlElement*)dest)->_childElement = std::make_unique<ScriptElement>();
                        break;
                    case SvgEL:
                        ((libhtmlpp::HtmlElement*)dest)->_childElement = std::make_unique<SvgElement>();
                        break;
                    case TextAreaEL:
                        ((libhtmlpp::HtmlElement*)dest)->_childElement = std::make_unique<TextArea>();
                        break;
                    default:
                        HTMLException ex;
                        ex[HTMLException::Critical] << "_copy: Unknown html element found !";
                        throw ex;
                }
                cpyel childel;
                childel.destin=((libhtmlpp::HtmlElement*)dest)->_childElement.get();
                childel.source=((libhtmlpp::HtmlElement*)src)->_childElement.get();
                cpylist.push(childel);
            }
        }else if(src->getType()==libhtmlpp::ScriptEL && dest->getType()== libhtmlpp::ScriptEL){
            ((libhtmlpp::ScriptElement*)dest)->_TagName=(((libhtmlpp::ScriptElement*)src)->_TagName);
            for(libhtmlpp::ScriptElement::Attributes *cattr=((libhtmlpp::ScriptElement*)src)->_firstAttr.get(); cattr; cattr=cattr->_nextAttr.get()){
                if(!cattr->_Value.empty()){
                    ((libhtmlpp::ScriptElement*)dest)->setAttribute(
                        std::string(
                            cattr->_Key.begin(),
                                    cattr->_Key.end()
                        ),std::string(
                            cattr->_Value.begin(),
                                      cattr->_Value.end()
                        )
                    );
                }else{
                    ((libhtmlpp::ScriptElement*)dest)->setAttribute(std::string(cattr->_Key.begin(),cattr->_Key.end()),"");
                }
            }
            ((ScriptElement*)dest)->_Script=(((ScriptElement*)src)->_Script);
        }else if(src->getType()==libhtmlpp::SvgEL && dest->getType()== libhtmlpp::SvgEL){
            ((libhtmlpp::SvgElement*)dest)->_TagName=(((libhtmlpp::SvgElement*)src)->_TagName);
            for(libhtmlpp::SvgElement::Attributes *cattr=((libhtmlpp::SvgElement*)src)->_firstAttr.get(); cattr; cattr=cattr->_nextAttr.get()){
                if(!cattr->_Value.empty()){
                    ((libhtmlpp::SvgElement*)dest)->setAttribute(
                        std::string(
                            cattr->_Key.begin(),
                                    cattr->_Key.end()
                        ),std::string(
                            cattr->_Value.begin(),
                                      cattr->_Value.end()
                        )
                    );
                }else{
                    ((libhtmlpp::SvgElement*)dest)->setAttribute(std::string(cattr->_Key.begin(),cattr->_Key.end()),"");
                }
            }
            ((SvgElement*)dest)->_Svg=(((SvgElement*)src)->_Svg);
        }else if(src->getType()==libhtmlpp::TextAreaEL&& dest->getType()== libhtmlpp::TextAreaEL){
            ((libhtmlpp::TextArea*)dest)->_TagName=(((libhtmlpp::TextArea*)src)->_TagName);
            for(libhtmlpp::TextArea::Attributes *cattr=((libhtmlpp::TextArea*)src)->_firstAttr.get(); cattr; cattr=cattr->_nextAttr.get()){
                if(!cattr->_Value.empty()){
                    ((libhtmlpp::TextArea*)dest)->setAttribute(
                        std::string(
                            cattr->_Key.begin(),
                                    cattr->_Key.end()
                        ),std::string(
                            cattr->_Value.begin(),
                                      cattr->_Value.end()
                        )
                    );
                }else{
                    ((libhtmlpp::TextArea*)dest)->setAttribute(std::string(cattr->_Key.begin(),cattr->_Key.end()),"");
                }
            }
            ((TextArea*)dest)->_Text=(((TextArea*)src)->_Text);
        }else if(src->getType()==libhtmlpp::TextEl && dest->getType()== libhtmlpp::TextEl){
            ((TextElement*)dest)->_Text=(((TextElement*)src)->_Text);
        }else if(src->getType()==libhtmlpp::CommentEl && dest->getType()== libhtmlpp::CommentEl){
            ((CommentElement*)dest)->_Comment=(((CommentElement*)src)->_Comment);
        }
 
        if(prev)
            dest->_prevElement=(Element*)prev;
 
        Element* next=src->nextElement();
 
        if(next){
            switch(next->getType()){
                case HtmlEl:
                    dest->_nextElement= std::make_unique<HtmlElement>();
                    break;
                case TextEl:
                    dest->_nextElement= std::make_unique<TextElement>();
                    break;
                case CommentEl:
                    dest->_nextElement= std::make_unique<CommentElement>();
                    break;
                case ScriptEL:
                    dest->_nextElement= std::make_unique<ScriptElement>();
                    break;
                case SvgEL:
                    dest->_nextElement= std::make_unique<SvgElement>();
                    break;
               case TextAreaEL:
                    dest->_nextElement= std::make_unique<TextArea>();
                    break;
                default:
                    HTMLException ex;
                    ex[HTMLException::Critical] << "_copy: Unknown next html element found !";
                    throw ex;
            }
            prev=dest;
            src=next;
            dest=dest->_nextElement.get();
            goto NEWEL;
        }
 
        if(!cpylist.empty()){
            cpyel childel(cpylist.top());
            prev=nullptr;
            dest=childel.destin;
            src=childel.source;
            cpylist.pop();
            goto NEWEL;
        }
 
        // Re-parent the whole copied subtree relative to originalDest --
        // never derived from src's original ancestry, since this copy may
        // be landing somewhere entirely different (e.g. a fresh standalone
        // object, or as a new child elsewhere). originalDest's OWN parent
        // is deliberately left untouched: that's always the caller's
        // responsibility (insertChild/appendChild set it explicitly right
        // after calling _copy; operator=/copy-ctors leave it as whatever
        // it already was, since copying INTO an object doesn't change
        // where that object itself lives).
        if(originalDest->getType()==HtmlEl){
            libhtmlpp::HtmlElement *destHel = static_cast<libhtmlpp::HtmlElement*>(originalDest);
            if(destHel->_childElement)
                libhtmlpp::HtmlElement::_assignParentPointers(destHel->_childElement.get(), originalDest);
        }
        return;
    }
};
 
void libhtmlpp::Element::insertBefore(libhtmlpp::Element* el){
    std::unique_ptr<Element> nel;
    switch(el->getType()){
        case HtmlEl:
            nel->_nextElement= std::make_unique<HtmlElement>();
            break;
        case TextEl:
            nel->_nextElement= std::make_unique<TextElement>();
            break;
        case CommentEl:
            nel->_nextElement= std::make_unique<CommentElement>();
            break;
        case ScriptEL:
            nel->_nextElement= std::make_unique<ScriptElement>();
            break;
        case SvgEL:
            nel->_nextElement= std::make_unique<SvgElement>();
            break;
        case TextAreaEL:
            nel->_nextElement= std::make_unique<TextArea>();
            break;
        default:
            HTMLException ex;
            ex[HTMLException::Critical] << "_copy: Unknown next html element found !";
            throw ex;
    }
    _copy(nel.get(),el);
    std::unique_ptr<Element> prev=std::move(_prevElement->_nextElement);
    _prevElement->_nextElement=std::move(nel);
    nel->_nextElement=std::move(prev);
}
 
void libhtmlpp::Element::insertAfter(libhtmlpp::Element* el){
    Element *nexel=nullptr,*prev=nullptr;
 
    switch(el->getType()){
         case HtmlEl:
            _nextElement= std::make_unique<HtmlElement>();
            break;
        case TextEl:
            _nextElement= std::make_unique<TextElement>();
            break;
        case CommentEl:
            _nextElement= std::make_unique<CommentElement>();
            break;
        case ScriptEL:
            _nextElement= std::make_unique<ScriptElement>();
            break;
        case SvgEL:
            _nextElement= std::make_unique<SvgElement>();
            break;
        case TextAreaEL:
            _nextElement= std::make_unique<TextArea>();
            break;
        default:
            HTMLException ex;
            ex[HTMLException::Critical] << "_copy: Unknown next html element found !";
            throw ex;
    }
 
    _copy(_nextElement.get(),el);
 
    nexel=_nextElement.get();
 
    while(nexel){
        prev=nexel;
        nexel=nexel->nextElement();
    }
 
    nexel=prev;
 
}
 
libhtmlpp::Element& libhtmlpp::Element::operator=(const Element &hel){
    _copy(this,&hel);
    return *this;
}
 
libhtmlpp::Element& libhtmlpp::Element::operator=(const Element *hel){
    _copy(this,hel);
    return *this;
}
 
libhtmlpp::Element *libhtmlpp::Element::nextElement() const{
    return _nextElement.get();
}
 
libhtmlpp::Element *libhtmlpp::Element::prevElement() const{
    return _prevElement;
}
 
libhtmlpp::Element *libhtmlpp::Element::parentElement() const{
    return _parentElement;
}
 
libhtmlpp::Element::Element(){
    _prevElement=nullptr;
    _nextElement=nullptr;
}
 
libhtmlpp::Element::Element(const libhtmlpp::Element& el){
    _prevElement=nullptr;
    _nextElement=nullptr;
    _copy(this,&el);
}
 
libhtmlpp::Element::~Element(){
    auto cur = std::move(_nextElement);
    while (cur) {
        cur = std::move(cur->_nextElement);
    }
};
 
void libhtmlpp::Element::remove(libhtmlpp::Element* el){
    Element *curel=this;
 
    while(curel){
        Element *next=curel->_nextElement.get();
 
        if(curel==el){
            // Whoever owns curel via a unique_ptr (curel->_prevElement's
            // own _nextElement) is about to be reassigned away from curel
            // below, which destroys curel immediately as part of that
            // assignment -- so everything needed from curel (its previous
            // sibling, and its own next-sibling chain, detached via
            // release() rather than a move that's still reachable through
            // curel) must be captured first, and curel must not be
            // touched afterward.
            Element *prev = curel->_prevElement;
            std::unique_ptr<Element> curelsNext(curel->_nextElement.release());
            if(next) next->_prevElement=prev;
            if(prev)
                prev->_nextElement=std::move(curelsNext); // destroys curel
            // else: curel has no previous sibling (e.g. `this` itself was
            // passed as `el`) -- the base class has no notion of a
            // parent's own child-pointer to repoint, so curel is left
            // unlinked-from but not destroyed.
            return;
        }
 
        curel=next;
    }
}
 
 
libhtmlpp::TextElement::TextElement() : Element() {
}
 
libhtmlpp::TextElement::TextElement(const std::string& txt) : TextElement(){
    setText(txt);
}
 
libhtmlpp::TextElement::TextElement(const TextElement &texel) : TextElement(){
    _copy(this,&texel);
}
 
libhtmlpp::TextElement::~TextElement(){
}
 
 
libhtmlpp::TextElement & libhtmlpp::TextElement::operator=(const libhtmlpp::Element& hel){
    _copy(this,&hel);
    return *this;
}
 
libhtmlpp::TextElement & libhtmlpp::TextElement::operator=(const libhtmlpp::Element* hel){
    _copy(this,hel);
    return *this;
}
 
void libhtmlpp::TextElement::setText(const std::string& txt){
    std::copy(txt.begin(),txt.end(),std::back_inserter(_Text));
}
 
const std::string libhtmlpp::TextElement::getText(){
    return std::string(_Text.begin(),_Text.end());
}
 
int libhtmlpp::TextElement::getType() const{
    return ElementType::TextEl;
}
 
size_t libhtmlpp::TextElement::parseElement(
    const std::vector<char>& in,
    std::unique_ptr<libhtmlpp::Element>& el,
    size_t start,
    bool &termination
){
    termination = false;
 
    std::vector<char> buf;
    buf.reserve(64);
    bool last_was_space = false;
 
    // A whitespace run always collapses to exactly one space, whether it's
    // leading, internal, trailing, or the entire run -- never to zero. A
    // leading run is just as significant as an internal one: it's what
    // separates this text from whatever inline element preceded it (e.g.
    // "</span> next word", or two adjacent elements separated only by
    // whitespace like "<a>A</a> <a>B</a>"). Dropping it silently glues
    // words together in the rendered output.
    size_t i = start;
    while (i < in.size()) {
        char c = in[i];
        if (c == HTMLTAG_OPEN) {
            break;
        }
 
        if (c == ' ' || c == '\t' || c == '\r' || c == '\n') {
            if (!last_was_space) {
                buf.push_back(' ');
                last_was_space = true;
            }
            ++i;
            continue;
        }
 
        buf.push_back(c);
        last_was_space = false;
        ++i;
    }
 
    if (!buf.empty()) {
        auto text = std::make_unique<TextElement>();
        (static_cast<TextElement*>(text.get()))->_Text.insert(
            (static_cast<TextElement*>(text.get()))->_Text.end(),
            buf.begin(), buf.end()
        );
        el = std::move(text);
    }
 
    return i;
}
 
 
libhtmlpp::CommentElement::CommentElement() : Element(){
}
 
libhtmlpp::CommentElement::CommentElement(const CommentElement &comel) : Element(){
    _copy(this,&comel);
}
 
libhtmlpp::CommentElement::~CommentElement(){
}
 
 
libhtmlpp::CommentElement & libhtmlpp::CommentElement::operator=(const libhtmlpp::Element& hel){
    _copy(this,&hel);
    return *this;
}
 
libhtmlpp::CommentElement & libhtmlpp::CommentElement::operator=(const libhtmlpp::Element* hel){
    _copy(this,hel);
    return *this;
}
 
void libhtmlpp::CommentElement::setComment(const std::string& txt){
    std::copy(txt.begin(),txt.end(),
              std::insert_iterator<std::vector<char>>(_Comment,_Comment.begin()));
}
 
const std::string libhtmlpp::CommentElement::getComment(){
    return std::string(_Comment.begin(),_Comment.end());
}
 
int libhtmlpp::CommentElement::getType() const{
    return ElementType::CommentEl;
}
 
size_t libhtmlpp::CommentElement::parseElement(
    const std::vector<char>& in,
    std::unique_ptr<Element>& el,
    size_t start,
    bool& termination
){
    termination = false;
 
    size_t i = start;
    if (i + 3 >= in.size()) return i;
 
    if (!(in[i] == '<' && in[i+1] == '!' && in[i+2] == '-' && in[i+3] == '-')) {
        return i;
    }
 
    el = std::make_unique<CommentElement>();
 
    i += 4;
    const size_t content_begin = i;
 
    while (i + 2 < in.size()) {
        if (in[i] == '-' && in[i+1] == '-' && in[i+2] == '>') {
            break;
        }
        ++i;
    }
 
    auto* self = static_cast<CommentElement*>(el.get());
    if (i > content_begin) {
        self->_Comment.insert(self->_Comment.end(),
                              in.begin() + content_begin,
                              in.begin() + i);
    }
 
    if (i + 2 < in.size()) {
        i += 3;
    } else {
        i = in.size();
    }
    return i;
}
 
 
libhtmlpp::ScriptElement::ScriptElement() : HtmlElement("script"){
}
 
libhtmlpp::ScriptElement::ScriptElement(const ScriptElement &scriptsrc) : HtmlElement("script"){
    _copy(this,&scriptsrc);
}
 
libhtmlpp::ScriptElement::~ScriptElement(){
}
 
 
libhtmlpp::ScriptElement & libhtmlpp::ScriptElement::operator=(const libhtmlpp::Element& hel){
    _copy(this,&hel);
    return *this;
}
 
libhtmlpp::ScriptElement & libhtmlpp::ScriptElement::operator=(const libhtmlpp::Element* hel){
    _copy(this,hel);
    return *this;
}
 
void libhtmlpp::ScriptElement::setScript(const std::string& script){
    _Script.assign(script.begin(),script.end());
}
 
const std::string libhtmlpp::ScriptElement::getScript(){
    return std::string(_Script.begin(),_Script.end());
}
 
int libhtmlpp::ScriptElement::getType() const{
    return ElementType::ScriptEL;
}
 
size_t libhtmlpp::ScriptElement::parseElement(
    const std::vector<char>& in,
    std::unique_ptr<Element>& el,
    size_t start,
    bool& termination
){
termination = false;
    el = std::make_unique<ScriptElement>();
    auto* self = static_cast<ScriptElement*>(el.get());
 
    size_t i = start;
    if (i >= in.size() || in[i] != '<') {
        // If it doesn't start with '<', we can't parse a tag here.
        return start;
    }
 
    // Helper to perform case-insensitive comparison
    auto iequals = [](char a, char b) {
        return std::tolower(static_cast<unsigned char>(a)) ==
               std::tolower(static_cast<unsigned char>(b));
    };
 
    // Helper to perform case-insensitive match for a keyword starting at 'pos'
    auto match_ci = [&](size_t pos, const char* k) -> bool {
        for (size_t j = 0; k[j]; ++j) {
            if (pos + j >= in.size() || !iequals(in[pos + j], k[j])) {
                return false;
            }
        }
        return true;
    };
 
    // --- 1. Validate Opening Tag Name (<script) ---
    ++i; // Consume '<'
 
    // Skip leading whitespace after '<'
    while (i < in.size() && std::isspace(static_cast<unsigned char>(in[i]))) {
        ++i;
    }
 
    const char* tag_keyword = "script";
    size_t keyword_len = std::char_traits<char>::length(tag_keyword);
 
    if (i + keyword_len >= in.size() || !match_ci(i, tag_keyword)) {
        // Tag name doesn't match "script"
        // Skip till next '>' and return the position after it.
        while (i < in.size() && in[i] != '>') {
            ++i;
        }
        if (i < in.size()) {
            ++i; // Consume '>'
        }
        return i;
    }
    i += keyword_len; // Consume "script"
 
    // --- 2. Extract Opening Tag and Attributes ---
    // Find the closing '>' of the opening tag.
    size_t tag_end = i;
    while (i < in.size() && in[i] != '>') {
        ++i;
    }
 
    // Capture the raw opening tag data (including '<script' and attributes) for serialization.
    if (i > start && in[i] == '>') {
        // Copy data from '<' (start) up to and including '>' (i)
        std::vector<char> raw_tag_data(in.begin() + start, in.begin() + i + 1);
        self->_serialelize(raw_tag_data);
    }
 
    if (i >= in.size() || in[i] != '>') {
        // The tag was never closed (e.g., '<script src="..." EOF')
        return i;
    }
 
    ++i; // Consume '>' and move to content start
    size_t content_begin = i;
 
    // --- 3. Extract Script Content (CDATA-like section) ---
    for (; i < in.size(); ++i) {
        // Look for the start of the closing tag sequence: </script
        if (in[i] == '<' && match_ci(i, "</script")) {
            size_t content_end = i;
 
            // 3a. Extract content preceding the closing tag
            if (content_end > content_begin) {
                // FIX: Use std::vector::insert instead of non-existent append
                self->_Script.insert(self->_Script.end(),
                                     in.begin() + content_begin,
                                     in.begin() + content_end);
            }
 
            // 3b. Find the end of the closing tag: </script>
            size_t closing_tag_end_pos = i + keyword_len + 2; // +2 for '</'
 
            // Skip any characters/whitespace between </script and the final '>'
            while (closing_tag_end_pos < in.size() && in[closing_tag_end_pos] != '>') {
                ++closing_tag_end_pos;
            }
 
            if (closing_tag_end_pos < in.size() && in[closing_tag_end_pos] == '>') {
                i = closing_tag_end_pos + 1; // Position after '>'
                return i;
            }
 
            // If we found "</script" but not the final ">", return the last processed position.
            return closing_tag_end_pos;
        }
    }
 
    // --- 4. End of Input Reached ---
    // If the input ends without a closing </script> tag, capture the remaining content.
    if (in.size() > content_begin) {
        // FIX: Use std::vector::insert instead of non-existent append
        self->_Script.insert(self->_Script.end(),
                             in.begin() + content_begin,
                             in.end());
    }
 
    return i;
}
 
 
 
libhtmlpp::SvgElement::SvgElement() : HtmlElement("svg"){
}
 
libhtmlpp::SvgElement::SvgElement(const SvgElement &svgsrc) : HtmlElement("svg"){
    _copy(this,&svgsrc);
}
 
libhtmlpp::SvgElement::~SvgElement(){
}
 
 
libhtmlpp::SvgElement & libhtmlpp::SvgElement::operator=(const libhtmlpp::Element& hel){
    _copy(this,&hel);
    return *this;
}
 
libhtmlpp::SvgElement & libhtmlpp::SvgElement::operator=(const libhtmlpp::Element* hel){
    _copy(this,hel);
    return *this;
}
 
void libhtmlpp::SvgElement::setSvg(const std::string& script){
    std::copy(script.begin(),script.end(),
              std::insert_iterator<std::vector<char>>(_Svg,_Svg.begin()));
}
 
const std::vector<char>libhtmlpp::SvgElement::getSvg(){
    return _Svg;
}
 
int libhtmlpp::SvgElement::getType() const{
    return ElementType::SvgEL;
}
 
size_t libhtmlpp::SvgElement::parseElement(const std::vector<char>& in,
                                           std::unique_ptr<libhtmlpp::Element>& el,
                                           size_t start,
                                           bool& termination)
{
    const size_t startel = start;
    termination = false;
 
    const auto begin = in.begin();
    if (start >= in.size()) {
        HTMLException excp;
        throw excp[HTMLException::Error] << "Parsing error: start offset beyond buffer.";
    }
    auto it_close_angle = std::find(begin + start, in.end(), HTMLTAG_CLOSE);
    if (it_close_angle == in.end()) {
        HTMLException excp;
        throw excp[HTMLException::Error] << "Parsing error: Missing '>' for <svg> open tag.";
    }
 
    el = std::make_unique<SvgElement>();
    auto* svgEl = static_cast<SvgElement*>(el.get());
 
    {
        std::vector<char> tel;
        tel.assign(begin + startel, it_close_angle);
        svgEl->_serialelize(tel, /*preserveAttrCase=*/true);
    }
 
    auto it_content_begin = it_close_angle;
    if (it_content_begin != in.end()) ++it_content_begin; // safe increment
 
    static constexpr char kEndTag[] = "</svg>";
    auto ci_eq = [](char a, char b) {
        auto lower = [](unsigned char c) -> unsigned char {
            return (c >= 'A' && c <= 'Z') ? static_cast<unsigned char>(c + 32) : c;
        };
        return lower(static_cast<unsigned char>(a)) == lower(static_cast<unsigned char>(b));
    };
    auto it_end = std::search(it_content_begin, in.end(),
                              std::begin(kEndTag), std::end(kEndTag) - 1 /* no '\0' */, ci_eq);
    if (it_end == in.end()) {
        HTMLException excp;
        throw excp[HTMLException::Error] << "Parsing error: Missing </svg> closing tag.";
    }
 
    svgEl->_Svg.insert(svgEl->_Svg.end(), it_content_begin, it_end);
 
    const size_t consumed = static_cast<size_t>((it_end - begin) + (std::size(kEndTag) - 1));
    return consumed;
}
 
 
 
libhtmlpp::TextArea::TextArea() : HtmlElement("svg"){
}
 
libhtmlpp::TextArea::TextArea(const TextArea &textsrc) : HtmlElement("text"){
    _copy(this,&textsrc);
}
 
libhtmlpp::TextArea::~TextArea(){
}
 
 
libhtmlpp::TextArea &libhtmlpp::TextArea::operator=(const libhtmlpp::Element& hel){
    _copy(this,&hel);
    return *this;
}
 
libhtmlpp::TextArea &libhtmlpp::TextArea::operator=(const libhtmlpp::Element* hel){
    _copy(this,hel);
    return *this;
}
 
void libhtmlpp::TextArea::setText(const std::string& text){
    std::copy(text.begin(),text.end(),
              std::insert_iterator<std::vector<char>>(_Text,_Text.begin()));
}
 
const std::vector<char>libhtmlpp::TextArea::getText(){
    return _Text;
}
 
int libhtmlpp::TextArea::getType() const{
    return ElementType::TextAreaEL;
}
 
size_t libhtmlpp::TextArea::parseElement(const std::vector<char>& in,
                                         std::unique_ptr<libhtmlpp::Element>& el,
                                         size_t start,
                                         bool& termination)
{
    termination = false;
 
    const auto begin = in.begin();
    const auto end   = in.end();
 
    if (start >= in.size()) {
        HTMLException excp;
        throw excp[HTMLException::Error] << "Parsing error: start offset beyond buffer.";
    }
 
    // ---- helpers -----------------------------------------------------------
    auto is_ws = [](unsigned char c) {
        return c == ' ' || c == '\t' || c == '\n' || c == '\r';
    };
    auto tolower_ascii = [](unsigned char c) -> unsigned char {
        return (c >= 'A' && c <= 'Z') ? static_cast<unsigned char>(c + 32) : c;
    };
    auto ieq_prefix = [&](std::vector<char>::const_iterator it,
                          std::vector<char>::const_iterator it_end,
                          const char* lit) -> bool
    {
        for (; *lit; ++lit, ++it) {
            if (it == it_end) return false;
            if (tolower_ascii(static_cast<unsigned char>(*it)) !=
                tolower_ascii(static_cast<unsigned char>(*lit))) {
                return false;
            }
        }
        return true;
    };
 
    auto it_gt = std::find(begin + start, end, HTMLTAG_CLOSE);
    if (it_gt == end) {
        HTMLException excp;
        throw excp[HTMLException::Error] << "Parsing error: Unclosed <textarea> tag.";
    }
 
    el = std::make_unique<TextArea>();
    auto* ta = static_cast<TextArea*>(el.get());
    {
        std::vector<char> tel;
        tel.assign(begin + start, it_gt);   // opening tag without '>'
        ta->_serialelize(tel);
    }
 
    auto it = it_gt;
    if (it != end) ++it;
    const auto content_begin = it;
 
    for (;;) {
        auto lt = std::find(it, end, '<');
        if (lt == end) {
            HTMLException excp;
            throw excp[HTMLException::Error] << "Parsing error: Missing </textarea> closing tag.";
        }
 
        if (ieq_prefix(lt, end, "</textarea")) {
            auto after_head = lt + std::strlen("</textarea");
            while (after_head != end && is_ws(static_cast<unsigned char>(*after_head))) {
                ++after_head;
            }
            if (after_head == end) {
                HTMLException excp;
                throw excp[HTMLException::Error] << "Parsing error: Unclosed </textarea> end tag.";
            }
            if (*after_head == '>') {
                ta->_Text.insert(ta->_Text.end(), content_begin, lt);
                const size_t consumed = static_cast<size_t>((after_head - begin) + 1);
                return consumed;
            }
 
            it = lt + 1;
            continue;
        }
 
        it = lt + 1;
    }
}
 
 
 
libhtmlpp::HtmlPage::HtmlPage(){
 
}
 
libhtmlpp::HtmlPage::~HtmlPage(){
}
void libhtmlpp::HtmlPage::loadFile(libhtmlpp::HtmlElement &html,const std::string& path){
    std::string data;
    std::ifstream fs(path);
 
    if(!fs.is_open()){
        HTMLException excp;
        throw excp[HTMLException::Critical] << "Can't open file: " << path;
    }
 
    fs.seekg(std::ios::end);
 
    data.reserve(fs.tellg());
 
    fs.seekg(std::ios::beg);
 
    data.assign((std::istreambuf_iterator<char>(fs)), std::istreambuf_iterator<char>());
 
    fs.close();
 
    _CheckHeader(data);
    loadString(html,data);
}
void libhtmlpp::HtmlPage::loadString(libhtmlpp::HtmlElement &html,const std::string &src){
    HtmlString buf=src;
    Element &el=buf.parse();
    _copy(&html,&el);
}
 
void libhtmlpp::HtmlPage::loadString(libhtmlpp::HtmlElement &html,const HtmlString &node){
    HtmlString buf=node;
    Element &el=buf.parse();
    _copy(&html,&el);
}
 
void loadString(libhtmlpp::HtmlElement &html,const libhtmlpp::HtmlString *node){
    if(!node){
        libhtmlpp::HTMLException excp;
        throw excp[libhtmlpp::HTMLException::Critical] << "loadstring: node can't be null !";
    }
    libhtmlpp::HtmlString buf=*node;
    html=(libhtmlpp::HtmlElement&)buf.parse();
}
void libhtmlpp::HtmlPage::saveFile(libhtmlpp::HtmlElement &html,const std::string& path){
    HtmlString data;
    std::ofstream fs;
 
    print(html,data);
 
    try{
        fs.open(path);
    }catch(std::exception &e){
        HTMLException excp;
        throw excp[HTMLException::Critical] << e.what();
    }
 
    fs << data.str();
 
    fs.close();
 
}
 
bool libhtmlpp::HtmlPage::isHtml5(){
    return _Html5;
}
 
 
void libhtmlpp::HtmlPage::_CheckHeader(const HtmlString &page){
    const char type[] = { '!','D','O','C','T','Y','P','E' };
 
    int i = 0;
 
    bool start=false;
 
    do{
        ++i;
        if(page[i]== '<'){
            if(start==true){
                HTMLException excp;
                excp[HTMLException::Critical] << "Wrong Header arborting";
                throw excp;
            }
            start=true;
        }
    } while ( page[i]== '<' || page[i]== '!' || page[i] == ' ');
 
    if (page.size() < 8) {
        HTMLException excp;
        excp[HTMLException::Critical] << "No Doctype found arborting";
        throw excp;
    }
 
    while (i < 8) {
        // Case-insensitive, matching the "HTML"/"PUBLIC" checks just below
        // and the HTML5 spec itself: "<!doctype html>" is exactly as valid
        // as "<!DOCTYPE HTML>", and is in fact the more common convention
        // in the wild (most build tools/frameworks emit it lowercase).
        if (tolower(page[i+1]) != tolower(type[i])) {
            HTMLException excp;
            excp[HTMLException::Critical] << "No Doctype found arborting";
            throw excp;
        }
        ++i;
    }
 
    do{
        ++i;
    }while (page[i] == ' ');
 
    const char doctype[] = { 'H','T','M','L' };
    size_t tpvl = 4;
 
    const char typevalue4[] = {'P','U','B','L','I','C'};
    size_t tpvl4 = 6;
 
    if ((i + tpvl) > page.size()) {
        HTMLException excp;
        excp[HTMLException::Critical] << "Document to short broken !";
        throw excp;
    }
 
    size_t ii=0;
 
    while ( ii < tpvl) {
        if (tolower(page[i++]) !=  tolower(doctype[ii++])) {
            HTMLException excp;
            excp[HTMLException::Critical] << "Doctype header broken or wrong type";
            throw excp;
        }
    }
 
    ii=0;
 
    do{
        ++i;
    } while (page[i] == ' ');
 
    bool html4=true;
 
    if(i +tpvl4  <page.size()){
        while(ii < tpvl4){
            if (tolower(page[i++]) !=  tolower(typevalue4[ii++])) {
                html4=false;
            }
        }
    }
 
    _Html5=!html4;
 
}
void libhtmlpp::print(const Element &element, HtmlString &output,bool formated) {
 
    const Element *el=&element;
 
    // Emit <!DOCTYPE html> when the root element is <html>
    if (el->getType() == HtmlEl) {
        const std::string &tag = static_cast<const HtmlElement*>(el)->getTagname();
        if (tag == "html") {
            output.append("<!DOCTYPE html>");
            if (formated)
                output.append("\n");
        }
    }
 
    auto isContainer = [](const std::string &tagname) {
        for(size_t i=0; i<ContainerTypes.size(); ++i){
            if(tagname==ContainerTypes[i])
                return true;
        }
        return false;
    };
 
    std::stack<const libhtmlpp::Element*> cpylist;
 
    int lvl=0;
 
    PRINTNEXTEL:
 
    if(formated){
        for(int i=0; i<lvl; ++i){
            output.append("    ");
        }
    }
 
    switch(el->getType()){
        case HtmlEl:{
            output.append("<");
            output.append(static_cast<const HtmlElement*>(el)->getTagname());
            for (HtmlElement::Attributes* curattr = static_cast<const HtmlElement*>(el)->_firstAttr.get(); curattr; curattr = curattr->_nextAttr.get()) {
                output.append(" ");
                std::copy(
                    curattr->_Key.begin(),
                          curattr->_Key.end(),
                          std::back_inserter(output)
                );
                // Always emit ="value", even when value is empty -- matches
                // the WHATWG HTML fragment serialization algorithm (browsers'
                // outerHTML never drops the ="" for e.g. alt="" or a boolean
                // attribute like disabled) and keeps round-tripping stable:
                // an attribute with an explicit empty value stays
                // distinguishable in the output from one with none.
                output.append("=\"");
                std::copy(
                    curattr->_Value.begin(),
                          curattr->_Value.end(),
                          std::back_inserter(output)
                );
                output.append("\"");
            }
 
            output.append(">");
 
            if (static_cast<const HtmlElement*>(el)->_childElement) {
                if(formated)
                    output.append("\r\n");
                cpylist.push(el);
                el=static_cast<const HtmlElement*>(el)->_childElement.get();
                ++lvl;
                goto PRINTNEXTEL;
            }
 
            //Container must be always terminated fuck html5
            if(isContainer(static_cast<const HtmlElement*>(el)->getTagname())){
                output.append("</");
                std::copy(
                    static_cast<const HtmlElement*>(el)->_TagName.begin(),
                          static_cast<const HtmlElement*>(el)->_TagName.end(),
                          std::back_inserter(output)
                );
                output.append(">");
            }
 
            if(formated)
                output.append("\r\n");
 
            if (el->_nextElement) {
                el=el->_nextElement.get();
                goto PRINTNEXTEL;
            }
        }break;
 
        case TextEl :{
            std::copy(
                static_cast<const TextElement*>(el)->_Text.begin(),
                      static_cast<const TextElement*>(el)->_Text.end(),
                      std::back_inserter(output)
            );
            if(formated)
                output.append("\r\n");
 
            if (el->_nextElement) {
                el=el->_nextElement.get();
                goto PRINTNEXTEL;
            }
        }break;
        case CommentEl: {
            output.append("<!--");
            std::copy(
                static_cast<const CommentElement*>(el)->_Comment.begin(),
                static_cast<const CommentElement*>(el)->_Comment.end(),
                std::back_inserter(output)
            );
            output.append("-->");
            if(formated)
                output.append("\r\n");
 
            if (el->_nextElement) {
                el=el->_nextElement.get();
                goto PRINTNEXTEL;
            }
        }break;
        case ScriptEL:{
            output.append("<");
            output.append(static_cast<const ScriptElement*>(el)->getTagname());
            for (ScriptElement::Attributes* curattr = static_cast<const ScriptElement*>(el)->_firstAttr.get(); curattr; curattr = curattr->_nextAttr.get()) {
                output.append(" ");
                std::copy(
                    curattr->_Key.begin(),
                          curattr->_Key.end(),
                          std::back_inserter(output)
                );
                // Always emit ="value", even when value is empty -- matches
                // the WHATWG HTML fragment serialization algorithm (browsers'
                // outerHTML never drops the ="" for e.g. alt="" or a boolean
                // attribute like disabled) and keeps round-tripping stable:
                // an attribute with an explicit empty value stays
                // distinguishable in the output from one with none.
                output.append("=\"");
                std::copy(
                    curattr->_Value.begin(),
                          curattr->_Value.end(),
                          std::back_inserter(output)
                );
                output.append("\"");
            }
 
            output.append(">");
            if(formated){
                output.append("\r\n");
                for(int i=0; i<lvl+1; ++i){
                    output.append("    ");
                }
            }
            std::copy(
                static_cast<const ScriptElement*>(el)->_Script.begin(),
                static_cast<const ScriptElement*>(el)->_Script.end(),
                std::back_inserter(output)
            );
            if(formated){
                output.append("\r\n");
                for(int i=0; i<lvl; ++i){
                    output.append("    ");
                }
            }
            output.append("</");
            output.append(static_cast<const ScriptElement*>(el)->getTagname());
            output.append(">");
            if(formated)
                output.append("\r\n");
 
            if (el->_nextElement) {
                el=el->_nextElement.get();
                goto PRINTNEXTEL;
            }
        }break;
        case SvgEL:{
            output.append("<");
            output.append(static_cast<const ScriptElement*>(el)->getTagname());
            for (SvgElement::Attributes* curattr = static_cast<const SvgElement*>(el)->_firstAttr.get(); curattr; curattr = curattr->_nextAttr.get()) {
                output.append(" ");
                std::copy(
                    curattr->_Key.begin(),
                          curattr->_Key.end(),
                          std::back_inserter(output)
                );
                // Always emit ="value", even when value is empty -- matches
                // the WHATWG HTML fragment serialization algorithm (browsers'
                // outerHTML never drops the ="" for e.g. alt="" or a boolean
                // attribute like disabled) and keeps round-tripping stable:
                // an attribute with an explicit empty value stays
                // distinguishable in the output from one with none.
                output.append("=\"");
                std::copy(
                    curattr->_Value.begin(),
                          curattr->_Value.end(),
                          std::back_inserter(output)
                );
                output.append("\"");
            }
            output.append(">");
 
            if(formated){
                output.append("\r\n");
                for(int i=0; i<lvl+1; ++i){
                    output.append("    ");
                }
            }
            std::copy(
                static_cast<const SvgElement*>(el)->_Svg.begin(),
                static_cast<const SvgElement*>(el)->_Svg.end(),
                std::back_inserter(output)
            );
            if(formated){
                output.append("\r\n");
                for(int i=0; i<lvl; ++i){
                    output.append("    ");
                }
            }
            output.append("</");
            output.append(static_cast<const SvgElement*>(el)->getTagname());
            output.append(">");
            if(formated)
                output.append("\r\n");
 
            if (el->_nextElement) {
                el=el->_nextElement.get();
                goto PRINTNEXTEL;
            }
        }break;
         case TextAreaEL:{
            output.append("<");
            output.append(static_cast<const TextArea*>(el)->getTagname());
            for (TextArea::Attributes* curattr = static_cast<const TextArea*>(el)->_firstAttr.get(); curattr; curattr = curattr->_nextAttr.get()) {
                output.append(" ");
                std::copy(
                    curattr->_Key.begin(),
                          curattr->_Key.end(),
                          std::back_inserter(output)
                );
                // Always emit ="value", even when value is empty -- matches
                // the WHATWG HTML fragment serialization algorithm (browsers'
                // outerHTML never drops the ="" for e.g. alt="" or a boolean
                // attribute like disabled) and keeps round-tripping stable:
                // an attribute with an explicit empty value stays
                // distinguishable in the output from one with none.
                output.append("=\"");
                std::copy(
                    curattr->_Value.begin(),
                          curattr->_Value.end(),
                          std::back_inserter(output)
                );
                output.append("\"");
            }
            output.append(">");
            std::copy(
                static_cast<const TextArea*>(el)->_Text.begin(),
                static_cast<const TextArea*>(el)->_Text.end(),
                std::back_inserter(output)
            );
            output.append("</");
            output.append(static_cast<const TextArea*>(el)->getTagname());
            output.append(">");
            if(formated)
                output.append("\r\n");
 
            if (el->_nextElement) {
                el=el->_nextElement.get();
                goto PRINTNEXTEL;
            }
        }break;
        default:
            HTMLException excp;
            excp[HTMLException::Error] << "Unkown Elementtype";
            throw excp;
            break;
    }
 
    while(!cpylist.empty()){
        el=cpylist.top();
 
        --lvl;
 
        if(formated){
            for(int i=0; i<lvl; ++i){
                output.append("    ");
            }
        }
 
        output.append("</");
        std::copy(
            static_cast<const HtmlElement*>(el)->_TagName.begin(),
            static_cast<const HtmlElement*>(el)->_TagName.end(),
            std::back_inserter(output)
        );
        output.append(">");
 
        if(formated)
            output.append("\r\n");
 
        cpylist.pop();
        if (el->_nextElement) {
            el=el->_nextElement.get();
            goto PRINTNEXTEL;
        }
    }
}
 
libhtmlpp::HtmlElement *libhtmlpp::HtmlElement::getElementbyID(const std::string &id) const{
    std::stack <Element*> childs;
    const Element *curel=this;
    SEARCHBYID:
    if(curel->getType()==HtmlEl || curel->getType()== ScriptEL || curel->getType()==SvgEL){
        if(((HtmlElement*)curel)->_childElement){
            childs.push(((HtmlElement*)curel)->_childElement.get());
        }
        std::string idname=((HtmlElement*)curel)->getAtributte("id");
        if(idname.length()==id.length() && std::equal(id.begin(),id.end(),idname.begin()) ){
            return (HtmlElement*)curel;
        }
    }
 
    if(curel->nextElement()){
        curel=curel->nextElement();
        goto SEARCHBYID;
    }
 
    if(!childs.empty()){
        curel=childs.top();
        childs.pop();
        goto SEARCHBYID;
    }
    return nullptr;
}
 
libhtmlpp::HtmlElement *libhtmlpp::HtmlElement::getElementbyTag(const std::string &tag) const{
    std::stack <Element*> childs;
    const Element *curel=this;
    SEARCHBYTAG:
    if(curel->getType()==HtmlEl || curel->getType()== ScriptEL || curel->getType()==SvgEL){
        if(((HtmlElement*)curel)->_childElement){
            childs.push(((HtmlElement*)curel)->_childElement.get());
        }
        const std::string tname=((HtmlElement*)curel)->getTagname();
        if(!tname.empty() && std::equal(tag.begin(),tag.end(),tname.begin())){
            return (HtmlElement*)curel;
        }
    }
 
    if(curel->nextElement()){
        curel=curel->nextElement();
        goto SEARCHBYTAG;
    }
 
    if(!childs.empty()){
        curel=childs.top();
        childs.pop();
        goto SEARCHBYTAG;
    }
    return nullptr;
}
 
libhtmlpp::Element* libhtmlpp::HtmlElement::firstChild() const {
    return _childElement.get();
}
 
const std::string libhtmlpp::HtmlElement::Attributes::getKey() const {
    return std::string(_Key.begin(), _Key.end());
}
 
const std::string libhtmlpp::HtmlElement::Attributes::getValue() const {
    return std::string(_Value.begin(), _Value.end());
}
 
libhtmlpp::HtmlElement::Attributes* libhtmlpp::HtmlElement::Attributes::nextAttribute() const {
    return _nextAttr.get();
}
 
const libhtmlpp::HtmlElement::Attributes* libhtmlpp::HtmlElement::firstAttribute() const {
    return _firstAttr.get();
}
 
void libhtmlpp::HtmlElement::setAttribute(const std::string &name, const std::string &value) {
    Attributes* cattr = nullptr;
 
    const char forbidden[] = {'\"'};
 
    auto checkForbidden = [forbidden](const std::string &input){
        for(size_t i = 0; i<input.length(); ++i){
            for(size_t ii=0; ii<sizeof(forbidden[ii]); ii++){
                if(input[i]==forbidden[ii]){
                    return true;
                }
            }
        }
        return false;
    };
 
    if(checkForbidden(name) || checkForbidden(value)){
        HTMLException e;
        e[HTMLException::Error] << "setAttribute " << name.c_str() << "forbidden sign is used !";
        throw e;
    }
 
    for (cattr= _firstAttr.get(); cattr; cattr=cattr->_nextAttr.get()) {
        if(name.size() == cattr->_Key.size() && std::equal(name.begin(),name.end(),cattr->_Key.begin())){
            cattr->_Value.clear();
            std::copy(value.begin(),value.end(),std::back_inserter(cattr->_Value));
            return;
        }
    }
    if (_lastAttr){
        _lastAttr->_nextAttr = std::make_unique<Attributes>();
        _lastAttr = _lastAttr->_nextAttr.get();
    }else {
        _firstAttr = std::make_unique<Attributes>();
        _lastAttr = _firstAttr.get();
    }
 
    cattr = _lastAttr;
    std::copy(name.begin(),name.end(),std::back_inserter(cattr->_Key) );
    std::copy(value.begin(),value.end(),std::back_inserter(cattr->_Value));
}
 
void libhtmlpp::HtmlElement::setIntAttribute(const std::string& name, int value) {
    char buf[255];
    snprintf(buf,255,"%d",value);
    setAttribute(name,buf);
}
 
const std::string libhtmlpp::HtmlElement::getAtributte(const std::string& name) const {
    for (Attributes* curattr = _firstAttr.get(); curattr; curattr = curattr->_nextAttr.get()) {
 
        if (curattr->_Key.size() != name.length() ) {
            continue;
        }
 
        if (std::equal(name.begin(), name.end(), curattr->_Key.begin())) {
            return std::string(curattr->_Value.begin(), curattr->_Value.end());
        }
    }
    return "";
}
 
int libhtmlpp::HtmlElement::getIntAtributte(const std::string& name) const
{
    return atoi(getAtributte(name).c_str());
}
 
libhtmlpp::HtmlElement::Attributes::Attributes() {
    _nextAttr=nullptr;
}
 
libhtmlpp::HtmlElement::Attributes::~Attributes() {
    auto cur = std::move(_nextAttr);
    while (cur) {
        cur = std::move(cur->_nextAttr);
    }
}
 
int libhtmlpp::HtmlElement::getType() const{
    return ElementType::HtmlEl;
}
 
 
libhtmlpp::HtmlTable::HtmlTable(){
    _firstRow=nullptr;
    _lastRow=nullptr;
    _count = 0;
}
 
libhtmlpp::HtmlTable::~HtmlTable(){
}
 
libhtmlpp::HtmlTable::Row &libhtmlpp::HtmlTable::operator<<(const Row& row){
    std::unique_ptr<Row> newRow = std::make_unique<Row>(row);
 
    if (!_firstRow) {
        _firstRow = std::move(newRow);
        _lastRow = _firstRow.get();
    } else {
        _lastRow->_nextRow = std::move(newRow);
        _lastRow = _lastRow->_nextRow.get();
    }
 
    ++_count;
    return *_lastRow;
}
 
libhtmlpp::HtmlTable::Row & libhtmlpp::HtmlTable::operator[](size_t pos){
    if(!_firstRow || _count<pos){
        libhtmlpp::HTMLException exp;
        exp[HTMLException::Error] << "HtmlTable: Row at this position won't exists !";
        throw exp;
    }
    size_t cpos=0;
    Row *curel=nullptr;
    for(curel=_firstRow.get(); curel; curel=curel->_nextRow.get()){
        if(cpos==pos)
            return *curel;
        ++cpos;
    }
    return *curel;
}
 
void libhtmlpp::HtmlTable::insert(libhtmlpp::HtmlElement* element){
    element->setTagname("table");
    for(Row *crow=_firstRow.get(); crow; crow=crow->_nextRow.get()){
        HtmlElement hrow("tr");
        for(Column *ccol=crow->_firstColumn.get(); ccol; ccol=ccol->_nextColumn.get() ){
            HtmlElement hcol("td");
            TextElement cellContent(ccol->Data.c_str());
            hcol.appendChild(cellContent);
            hrow.appendChild(hcol);
        }
        element->appendChild(&hrow);
    }
}
 
 
void libhtmlpp::HtmlTable::parse(libhtmlpp::HtmlElement* element){
}
 
void libhtmlpp::HtmlTable::setHeader(int count,...){
    va_list args;
    va_start(args,count);
 
    for (int i = 0; i < count; ++i) {
        _header << va_arg(args, const char*);
    }
 
}
 
void libhtmlpp::HtmlTable::deleteRow(size_t pos){
    if (pos >= _count)
        return;
    if (pos == 0) {
        _firstRow = std::move(_firstRow->_nextRow);
        _lastRow = (pos == (_count - 1)) ? nullptr : _firstRow.get();
    } else {
        Row *prev = &(*this)[pos - 1];
        if (prev->_nextRow) {
            prev->_nextRow = std::move(prev->_nextRow->_nextRow);
 
            if (prev->_nextRow.get() == nullptr) {
                _lastRow = prev;
            }
        }
    }
 
    --_count;
    if (_count == 0) {
        _firstRow = nullptr;
        _lastRow = nullptr;
    }
}
 
libhtmlpp::HtmlTable::Column::Column(){
    _nextColumn=nullptr;
}
 
libhtmlpp::HtmlTable::Column::Column(const libhtmlpp::HtmlTable::Column& col){
    _nextColumn=nullptr;
    Data = col.Data;
}
 
libhtmlpp::HtmlTable::Column::Column(const std::string &data){
    _nextColumn=nullptr;
    Data=data;
}
 
libhtmlpp::HtmlTable::Column::Column(const HtmlString &data){
    _nextColumn=nullptr;
    Data=data.str();
}
 
libhtmlpp::HtmlTable::Column::~Column(){
}
 
libhtmlpp::HtmlTable::Column::Column(libhtmlpp::HtmlTable::Column&& col) noexcept {
    _nextColumn = std::move(col._nextColumn);
    Data = std::move(col.Data);
}
 
libhtmlpp::HtmlTable::Row::Row(){
    _firstColumn=nullptr;
    _lastColumn=nullptr;
    _nextRow=nullptr;
    _count=0;
}
 
libhtmlpp::HtmlTable::Row::~Row(){
}
 
libhtmlpp::HtmlTable::Row::Row(const libhtmlpp::HtmlTable::Row& row){
    _firstColumn=nullptr;
    _lastColumn=nullptr;
    _nextRow=nullptr;
    _count=0;
 
    for(Column *curel=row._firstColumn.get(); curel; curel=curel->_nextColumn.get()){
        *this << HtmlString(curel->Data);
    }
}
 
libhtmlpp::HtmlTable::Row& libhtmlpp::HtmlTable::Row::operator<<(Column &&col){
    std::unique_ptr<Column> ptr = std::make_unique<Column>(std::move(col));
 
    if(_firstColumn){
        _lastColumn->_nextColumn=std::move(ptr);
        _lastColumn=_lastColumn->_nextColumn.get();
    }else{
        _firstColumn= std::move(ptr);
        _lastColumn=_firstColumn.get();
    }
    ++_count;
    return *this;
}
 
libhtmlpp::HtmlTable::Row& libhtmlpp::HtmlTable::Row::operator<<(const Column &col){
    std::unique_ptr<Column> ptr = std::make_unique<Column>(col);
 
    if(_firstColumn){
        _lastColumn->_nextColumn=std::move(ptr);
        _lastColumn=_lastColumn->_nextColumn.get();
    }else{
        _firstColumn= std::move(ptr);
        _lastColumn=_firstColumn.get();
    }
    ++_count;
    return *this;
}
 
libhtmlpp::HtmlTable::Row &libhtmlpp::HtmlTable::Row::operator<<(const libhtmlpp::HtmlString &value){
    Column col(value);
    *this << col;
    return *this;
}
 
libhtmlpp::HtmlTable::Row &libhtmlpp::HtmlTable::Row::operator<<(const std::string &value){
    Column col(value);
    *this << col;
    return *this;
}
 
 
libhtmlpp::HtmlTable::Row &libhtmlpp::HtmlTable::Row::operator<<(const char* value){
    HtmlString buf;
    buf << value;
    *this << buf;
    return  *this;
}
 
libhtmlpp::HtmlTable::Row & libhtmlpp::HtmlTable::Row::operator<<(int value){
    char buf[255];
    snprintf(buf,255,"%d",value);
    return *this << buf;
}
 
libhtmlpp::HtmlTable::Column & libhtmlpp::HtmlTable::Row::operator[](size_t pos){
    if(!_firstColumn || _count<pos){
        libhtmlpp::HTMLException exp;
        exp[HTMLException::Error] << "HtmlTable: Column at this position won't exists !";
        throw exp;
    }
    size_t cpos=0;
    Column *curel=nullptr;
    for(curel=_firstColumn.get(); curel; curel=curel->_nextColumn.get()){
        if(cpos==pos)
            return *curel;
        ++cpos;
    }
    return *curel;
}
 
void libhtmlpp::HtmlTable::Row::delColumn(size_t pos){
    Column *dcol=&(*this)[pos];
    try{
        Column *prev=&(*this)[pos-1];
        prev->_nextColumn=std::move(dcol->_nextColumn);
    }catch(...){}
    --_count;
}
 
void libhtmlpp::HtmlTable::Row::clear(){
    _firstColumn.reset();
    _lastColumn = nullptr;
    _count = 0;
}