/// This module provides syntax for generating HTML and XML documents from inside of D.
/// It supports embedded control flow (`if`, `foreach`, etc) and writing to output ranges.
///
/// $(B See the [#examples|examples] to get started!)
///
/// Note that the generator, at the moment, only supports HTML generation. While its output should
/// be a valid XML document, it is unable to create tags other than HTML's own. The old
/// [XML API](elemi.xml.html) should still be suitable for use with XML.
///
/// History: $(LIST
///     * Introduced in Elemi 1.4.0
/// )
module elemi.generator;

/// The [buildHTML] function is the entrypoint to generating HTML. Connect it to a HTML source:
/// a function to fill the HTML document with content.
@safe unittest {
    string output = buildHTML() ~ (html) {

    };
}

/// Elements are created using a tilde, followed by curly braces. This syntax is called an
/// $(B element block).
@safe unittest {
    string output = buildHTML() ~ (html) {
        html.div ~ {
            html.span ~ { };
        };
    };
    assert(output == "<div><span></span></div>");
}

/// Instead of a block, you can follow an element with a string to specify text content.
@safe unittest {
    string output = buildHTML() ~ (html) {
        html.p ~ "Hello, World!";
    };
    assert(output == "<p>Hello, World!</p>");
}

/// You can add attributes to an element using the [Tag.attr] method.
@safe unittest {
    string output = buildHTML() ~ (html) {
        html.a.attr("href", "https://example.com") ~ "Visit my website!";
    };
    assert(output == `<a href="https://example.com">Visit my website!</a>`);
}

/// Common HTML attributes are available through specialized methods.
@safe unittest {
    string output = buildHTML() ~ (html) {
        html.div.id("my-div") ~ { };
        html.div.classes("one", "two", "three") ~ { };
        html.a.href("https://example.com") ~ { };
    };
    assert(output == `<div id="my-div"></div>`
        ~ `<div class="one two three"></div>`
        ~ `<a href="https://example.com"></a>`);
}

/// Use control flow statements like `if` and `foreach` to generate HTML with code.
@safe unittest {
    string output = buildHTML() ~ (html) {
        html.ul ~ {
            foreach (item; ["1", "2", "3"]) {
                html.li ~ item;
            }
        };
    };
    assert(output == `<ul><li>1</li><li>2</li><li>3</li></ul>`);
}

/// Omit the tag name to append text directly.
@safe unittest {
    string output = buildHTML() ~ (html) {
        html ~ "Hello, ";
        html.strong ~ "World!";
    };
    assert(output == "Hello, <strong>World!</strong>");
}

/// Keep your document safe from XSS injections: all HTML content is escaped automatically.
///
/// Warning: Elemi will $(B not) escape
/// [javascript links](https://developer.mozilla.org/en-US/docs/Web/URI/Reference/Schemes/javascript).
/// If you let your users input URLs, make sure to block the `javascript:` schema.
@safe unittest {
    string output = buildHTML() ~ (html) {
        html ~ "<script>alert('fool!')</script>";
        html.input.attr("value", "\" can't quit me") ~ { };
        html.div.classes("classes are <no exception>") ~ { };
    };

    assert(output == `&lt;script&gt;alert(&#39;fool!&#39;)&lt;/script&gt;`
        ~ `<input value="&quot; can&#39;t quit me"/>`
        ~ `<div class="classes are &lt;no exception&gt;"></div>`);
}

static if (withInterpolation) {
    /// Interpolated expression strings, aka istrings, are supported.
    unittest {
        string output = buildHTML() ~ (html) {
            const user = "<user>";
            html ~ i"Hello $(user)";
            html.div ~ i"Hello $(user)";
            html.div.attr("name", i"$(user)") ~ { };
            html.a.href(i"https://example.com/$(user)") ~ { };
            html.a
                .classes("button", "special")
                .href("https://example.com/") ~ { };
        };
        assert(output == `Hello &lt;user&gt;`
            ~ `<div>Hello &lt;user&gt;</div>`
            ~ `<div name="&lt;user&gt;"></div>`
            ~ `<a href="https://example.com/&lt;user&gt;"></a>`
            ~ `<a class="button special" href="https://example.com/"></a>`);
    }
}

static if (withInterpolation) {

    /// This syntax can be mixed with elements generated by the old syntax.
    @safe unittest {
        string output = buildHTML() ~ (html) {
            html ~ elem!"span"();
            html.div ~ elem!"span"();
            html ~ i"$(elem!"span"())";
        };
        assert(output == `<span></span>`
            ~ `<div><span></span></div>`
            ~ `<span></span>`);
    }

}

/// Elemi works at compile time!
@safe unittest {
    enum output = buildHTML ~ (html) {
        html.div ~ {
            html.p ~ "Hello, World!";
        };
    };
    assert(output == "<div><p>Hello, World!</p></div>");
}


@safe unittest {
    string output = buildHTML() ~ (html) {
        html ~ elem!"p"("Hello, World!");
    };

    assert(output == "<p>Hello, World!</p>");
}

@safe unittest {
    // const(edgecase)
    const element = elem!"p"("Hello, World!");
    string output = buildHTML() ~ (html) {
        html ~ element;
        html ~ i" with $(element)";
    };

    assert(output == "<p>Hello, World!</p> with <p>Hello, World!</p>");
}

@safe unittest {
    // buildHTML() ~ null should work
    void delegate(HTML) @safe htmlBuilder;
    void delegate(HTML) @safe builder;

    string output1 = buildHTML() ~ htmlBuilder;
    assert(output1 == "");

    string output2 = buildHTML() ~ (html) {
        html ~ builder;
    };
    assert(output2 == "");

    string output3 = buildHTML ~ builder;
    assert(output3 == "");

}

import std.meta;
import std.range;
import std.string;
import std.functional;

import elemi.html;
import elemi.element;
import elemi.internal;
import elemi.attribute;

static if (__traits(compiles, { import core.attribute : mustuse; })) {
    import core.attribute : mustuse;
}
else {
    alias mustuse = AliasSeq!();
}

@safe:

/// Generic XML or HTML tag.
@mustuse
struct Tag {

    /// Output target for this tag; XML/HTML code will be written to this destination.
    DocumentOutput output;

    /// Name of the XML or HTML tag, for example `book` for `<book>` or `div` for `<div></div>`.
    string tagName;

    /// If true, this is a "self-closing" tag. No child nodes or text can be added.
    bool isSelfClosing;

    /// The tag can be marked as self-closing so it does not generate content nor an end tag.
    unittest {
        auto normal = buildHTML() ~ (html) {
            Tag(html, "a") ~ { };
        };
        auto selfClosing = buildHTML() ~ (html) {
            Tag(html, "a").makeSelfClosing() ~ { };
        };

        assert(normal == "<a></a>");
        assert(selfClosing == "<a/>");
    }

    unittest {
        auto normal = buildHTML() ~ (html) {
            Tag(html, "a").attr("k", "k") ~ { };
        };
        auto selfClosing = buildHTML() ~ (html) {
            Tag(html, "a").attr("k", "k").makeSelfClosing() ~ { };
        };

        assert(normal == `<a k="k"></a>`);
        assert(selfClosing == `<a k="k"/>`);
    }

    /// True if an attribute has been added to this tag.
    ///
    /// This changes whether the whole opening tag will be added when content starts (no
    /// attributes), or just the right bracket (with attributes).
    bool withAttributes;

    alias output this;

    /// Returns:
    ///     The same tag, but marked using [withAttributes]. This should be used to return from
    ///     attribute-adding methods.
    Tag attributed() const @safe {
        return Tag(output, tagName, isSelfClosing, true);
    }

    /// Returns:
    ///     This tag, but edited to be self-closing.
    Tag makeSelfClosing() const @safe {
        return Tag(output, tagName, true, withAttributes);
    }

    void opBinary(string op : "~")(typeof(null)) @safe {
        begin();
        end();
    }

    void opBinary(string op : "~", T)(T content) @safe {
        begin();
        if (!isSelfClosing) {
            static if (is(T : const Element)) {
                pushElementMarkup(content);
            }
            else {
                pushElementText(content);
            }
            end();
        }
    }

    static if (withInterpolation)
    void opBinary(string op : "~", Ts...)(InterpolationHeader, Ts text) {
        begin();
        if (!isSelfClosing) {
            pushElementText(text);
            end();
        }
    }

    void opBinary(string op : "~")(void delegate() @safe builder) @safe {
        begin();
        if (!isSelfClosing && builder !is null) {
            builder();
        }
        end();
    }

    void opBinary(string op : "~")(void delegate() @system builder) @system {
        begin();
        if (!isSelfClosing && builder !is null) {
            builder();
        }
        end();
    }

    /// Specify attributes using strings as key-value pairs. Interpolated strings are also
    /// accepted.
    ///
    /// Note:
    ///     At present, when using interpolated strings, the equals sign MUST be part of the
    ///     literal, and cannot be interpolated.
    ///
    ///     An expression like this is allowed: `i"$(key)=$(value)"`. However, if the
    ///     equal sign is interpolated, it will produce malformed code. Thus, a piece like
    ///     `i"$("key=value")"` would fail.
    Tag opIndex(Ts...)(Ts args) @safe {
        import std.algorithm : findSplit, filter, joiner;

        bool isValue;

        foreach (i, arg; args) {
            alias A = typeof(arg);
            static if (isInterpolation!(i, Ts)) {
                static if (is(A == InterpolationHeader)) {
                    beginAttributes();
                    withAttributes = true;
                    isValue = false;
                    pushElementMarkup(" ");
                }
                else static if (is(A == InterpolationFooter)) {
                    if (isValue) {
                        pushElementMarkup(`"`);
                    }
                    else {
                        pushElementMarkup(`=""`);
                    }
                }
                else static if (is(A == InterpolatedLiteral!text, string text)) {
                    auto pair = text.findSplit("=");
                    if (!isValue && pair) {
                        pushElementText(pair[0]);
                        pushElementMarkup(`="`);
                        pushElementText(pair[2]);
                        isValue = true;
                    }
                    else {
                        pushElementText(text);
                    }
                }
                else static if (isInputRange!A && is(ElementType!A : string)) {
                    pushElementText(arg
                        .filter!(a => a != "")
                        .joiner(" "));
                }
                else {
                    pushElementText(arg);
                }
            }
            else static if (is(A == string)) {
                auto pair = arg.findSplit("=");
                this = attr(pair[0], pair[2]);                
            }
            else static assert(false, "Unsupported argument type " ~ A.stringof);
        }

        return attributed;
    }

    /// Each string (or istring) defines a single attribute. The first equals-sign in the string
    /// separates the key from the value:
    unittest {
        string output = buildHTML() ~ (html) {
            html.div["id=mydiv", "class=apple orange"] ~ { };
        };
        assert(output == `<div id="mydiv" class="apple orange"></div>`);
    }

    /// The equals sign is optional. If missing, the value will be empty.
    unittest {
        string output = buildHTML() ~ (html) {
            html.input["type=checkbox", "checked"] ~ { };
        };
        assert(output == `<input type="checkbox" checked=""/>`);
    }

    /// Interpolated strings are supported. Ranges of strings are automatically joined with spaces.
    static if (withInterpolation) {
        unittest {
            int number = 1;
            string[] classes = ["two", "three", "four"];
            
            string output = buildHTML() ~ (html) {
                html.div[i"id=item-$(number)", i"class=one $(classes) five", "checked"] ~ { };
            };
            assert(output == `<div id="item-1" class="one two three four five" checked=""></div>`);
        }

        /// Attribute names can also be interpolated.
        unittest {
            string key = "data-foo";
            string output1 = buildHTML() ~ (html) {
                html.div[i"$(key)=value"] ~ { };
            };
            assert(output1 == `<div data-foo="value"></div>`);

            string state = "checked";
            string output2 = buildHTML() ~ (html) {
                html.input[i"$(state)", "type=checkbox"] ~ { };
            };
            assert(output2 == `<input checked="" type="checkbox"/>`);
        }

        unittest {
            string key = "data";
            string output = buildHTML() ~ (html) {
                html.div[i"$(key)=$(key)=$(key)"] ~ { };
            };
            assert(output == `<div data="data=data"></div>`);
        }

        static assert( __traits(compiles, Tag()[i"$(1)"]));
        static assert(!__traits(compiles, Tag()[1]));
    }

    /// Add an attribute to the element.
    /// Params:
    ///     name  = Name of the attribute.
    ///     value = Value for the attribute. Supports istrings.
    /// Returns:
    ///     Tag builder.
    Tag attr(string name, string value) @safe {
        return attr(Attribute(name, value));
    }

    /// ditto
    static if (withInterpolation) {
        Tag attr(Ts...)(string name, InterpolationHeader, Ts value) @safe {
            beginAttributes();
            pushElementMarkup(" ");
            pushElementMarkup(name);
            pushElementMarkup(`="`);
            pushElementText(value);
            pushElementMarkup(`"`);
            return attributed;
        }
    }

    /// Add a prepared set of attributes to the element.
    /// Params:
    ///     attributes = Attributes to add to the element.
    /// Returns:
    ///     Tag builder.
    Tag attr(Attribute[] attributes...) @safe {
        beginAttributes();
        foreach (attribute; attributes) {
            pushElementMarkup(" ");
            pushElementMarkup(attribute.name);
            pushElementMarkup(`="`);
            pushElementText(attribute.value);
            pushElementMarkup(`"`);
        }
        return attributed;
    }

    void begin() @safe {
        if (tagName is null) return;
        if (!withAttributes) {
            pushElementMarkup("<");
            pushElementMarkup(tagName);
        }
        if (isSelfClosing) {
            pushElementMarkup("/>");
        }
        else {
            pushElementMarkup(">");
        }
    }

    void beginAttributes() @safe {
        if (tagName is null) return;
        if (!withAttributes) {
            pushElementMarkup("<");
            pushElementMarkup(tagName);
        }
    }

    void end() @safe {
        if (tagName is null) return;
        if (!isSelfClosing) {
            pushElementMarkup("</");
            pushElementMarkup(tagName);
            pushElementMarkup(">");
        }
    }

}

/// A wrapper over a function, with additional methods added to support XML/HTML generation.
struct DocumentOutput {

    /// Function to call to append a string fragment to the output.
    void delegate(string fragment) @safe elementOutput;

    /// Append a string or [Element] to the stream.
    /// Params:
    ///     rhs = `string` or `Element` to append.
    void opBinary(string op : "~", T : string)(T rhs) @safe {
        static if (is(T : const Element)) {
            pushElementMarkup(rhs);
        }
        else {
            pushElementText(rhs);
        }
    }

    static if (withInterpolation) {
        /// Write an [istring](https://dlang.org/spec/istring.html) to the stream.
        /// Params:
        ///     text = Text to write.
        void opBinary(string op : "~", Ts...)(InterpolationHeader, Ts text) {
            pushElementText(text);
        }
    }

    /// Low-level function to write elements into current document context. Raw markup can be used,
    /// i.e. ("<b>Hi</b>")` will include unescaped HTML code.
    ///
    /// If escaping is desired, try [pushElementText].
    ///
    /// Params:
    ///     content = Markup to output.
    void pushElementMarkup(string content) @safe {
        assert(elementOutput !is null,
            "No Elemi context is currently active. Try prepending the document with "
            ~ "`buildDocument() ~`.");
        elementOutput(content);
    }

    /// Low-level function to write escaped text.
    ///
    /// Any of the characters `<` (less than sign), `>` (greater than sign), `&` (ampersand),
    /// `"` (quote mark), or `'` (apostrophe) will be replaced with the corresponding XML escape
    /// code.
    ///
    /// Params:
    ///     content = Content to write. Interpolated expression strings (istrings) are supported.
    void pushElementText(string content) {
        while (!content.empty) {
            const nextMarkup = content.indexOfAny(`<>&"'`);

            // No markup remains to be escaped
            if (nextMarkup == -1) {
                pushElementMarkup(content);
                return;
            }

            // Escape the character
            else {
                pushElementMarkup(content[0 .. nextMarkup]);
                pushElementMarkup(content[nextMarkup].escapeXML);
                content = content[nextMarkup + 1 .. $];
            }

        }
    }

    /// ditto
    void pushElementText(Ts...)(Ts content) {

        import std.format.write;

        auto writer = EscapingElementWriter(this);

        foreach (item; content) {
            static if (is(typeof(item) : Element)) {
                pushElementMarkup(item);
            }
            else {
                formattedWrite!"%s"(writer, item);
            }
        }

    }

    /// This output range writes escapes the text it writes.
    private struct EscapingElementWriter {

        DocumentOutput output;

        void put(char content) {
            if (auto escaped = escapeXML(content)) {
                output.pushElementMarkup(escaped);
            }
            else {
                immutable(char)[1] c = content;
                output.pushElementMarkup(c[]);
            }
        }

        void put(string content) {
            output.pushElementText(content);
        }

    }

}

/// Escape an ASCII character using HTML escape codes.
/// Returns:
///     A corresponding HTML escape code, or null if there isn't one.
private string escapeXML(char ch) {
    switch (ch) {
        case '<':  return "&lt;";
        case '>':  return "&gt;";
        case '&':  return "&amp;";
        case '"':  return "&quot;";
        case '\'': return "&#39;";
        default:   return null;
    }
}

/// HTML tag builder.
///
/// Params:
///     name = Name of the tag, for example `div`.
struct HTMLTag(string name) {

    /// True if the tag is one of HTML's
    /// [void elements](https://developer.mozilla.org/en-US/docs/Glossary/Void_element).
    /// Void elements do not have an end tag, and thus, cannot have child nodes.
    enum isVoidTag = name == "area"
        || name == "base"
        || name == "br"
        || name == "col"
        || name == "command"
        || name == "embed"
        || name == "hr"
        || name == "img"
        || name == "input"
        || name == "keygen"
        || name == "link"
        || name == "meta"
        || name == "param"
        || name == "source"
        || name == "track"
        || name == "wbr";

    /// XML tag wrapped by this struct; tag this struct corresponds to.
    Tag tag;

    alias tag this;

    /// Create a new instance of this tag for the specified document output.
    /// Params:
    ///     output = Document output instance this generator should write to.
    this(DocumentOutput output) {
        this.tag = Tag(output, name, isVoidTag);
    }

    /// Pass any other tag as an instance of this tag.
    /// Params:
    ///     tag = XML or HTML tag to wrap.
    this(Tag tag) {
        this.tag = tag;
    }

    /// Add an attribute to this element. This function wraps [Tag.attr].
    HTMLTag attr(Ts...)(Ts args) {
        return HTMLTag(
            tag.attr(args));
    }

    /// Returns:
    ///     The same tag, but marked using [Tag.withAttributes]. This should be used to return
    ///     from attribute-adding methods.
    HTMLTag attributed() {
        return HTMLTag(
            tag.attributed());
    }

    /// Add an `id` attribute to the HTML tag.
    /// Params:
    ///     value = Value to use for the attribute. Supports istrings.
    /// Returns:
    ///     Tag builder, for chaining.
    HTMLTag id(string value) @safe {
        return attr("id", value);
    }

    static if (withInterpolation) {
        /// ditto
        HTMLTag id(Ts...)(InterpolationHeader header, Ts value) @safe {
            return attr("id", header, value);
        }
    }

    /// Add a `class` attribute to a HTML tag from an array of strings.
    /// Params:
    ///     values = Classes to write, as an array. This array will be joined with spaces.
    /// Returns:
    ///     Tag builder, for chaining.
    HTMLTag classes(string[] values...) @safe {
        beginAttributes();
        pushElementMarkup(` class="`);
        foreach (i, value; values) {
            if (i) pushElementMarkup(" ");
            pushElementText(value);
        }
        pushElementMarkup(`"`);
        return attributed;
    }

    /// Set the "href" attribute for an `<a>` element.
    /// Params:
    ///     value = Value to use for the attribute. Supports istrings.
    /// Returns:
    ///     A tag builder.
    HTMLTag href(string value) @safe {
        return attr("href", value);
    }

    static if (withInterpolation) {
        /// ditto
        HTMLTag href(Ts...)(InterpolationHeader header, Ts value) @safe {
            return attr("href", header, value);
        }
    }

}

/// Write HTML elements to an output range.
/// Params:
///     range = Output range to write the output to. If not given, the builder will return
///         a string.
/// Returns:
///     A struct that accepts an element block `~ (html) { }` and writes the content to the output
///     range.
/// See_Also:
///     [HTML], the stream structure used to output data.
HTML buildHTML(T)(ref T range)
if (isOutputRange!(T, char))
do {
    return HTML(
        DocumentOutput(fragment => put(range, fragment)));
}

/// Write HTML elements to a string or [Element].
///
/// Returns:
///     A struct that accepts an element block `~ (html) { }` and writes the content to a string.
///
///     The resulting content will be wrapped in an [Element], making it compatible with the
///     [old elemi API](elemi.html.html). Note that metadata is not preserved, so adding
///     attributes or child nodes from `Element` will not be possible.
/// See_Also:
///     [HTML], the stream structure used to output data.
TextHTML buildHTML() @safe {
    return TextHTML();
}

/// If no arguments are specified, `buildHTML()` will output to a string. Under the hood,
/// it uses an [std.array.Appender].
@safe unittest {
    import std.array;
    string stringOutput = buildHTML() ~ (html) {
        html.p ~ "Hello!";
    };

    Appender!string rangeOutput;
    buildHTML(rangeOutput) ~ (html) {
        html.p ~ "Hello!";
    };
    assert(stringOutput == rangeOutput[]);
}

/// Supporting structure for [buildHTML].
struct TextHTML {
    import std.array;

    Element opBinary(string op : "~")(void delegate(HTML) @system rhs) const @system {
        Appender!string output;
        if (rhs !is null) {
            rhs(
                HTML(
                    DocumentOutput(fragment => output ~= fragment)));
        }
        return elemTrusted(output[]);
    }

    Element opBinary(string op : "~")(void delegate(HTML) @safe rhs) const @safe {
        Appender!string output;
        if (rhs !is null) {
            rhs(
                HTML(
                    DocumentOutput(fragment => output ~= fragment)));
        }
        return elemTrusted(output[]);
    }

}

/// A set of HTML tags to build documents with.
///
/// This structure includes a set of methods for creating HTML tags.
struct HTML {

    DocumentOutput documentOutput;

    alias documentOutput this;

    /// Write a string to the output stream.
    /// Params:
    ///     rhs = String to write.
    void opBinary(string op : "~", T : string)(T rhs) @safe {
        documentOutput ~ rhs;
    }

    static if (withInterpolation) {
        /// Write an [istring](https://dlang.org/spec/istring.html) to the output stream.
        /// Params:
        ///     rhs = String to write.
        void opBinary(string op : "~", Ts...)(InterpolationHeader, Ts text) {
            pushElementText(text);
        }
    }

    /// Pass self to a function.
    /// Params:
    ///     rhs = The function to read the output.
    void opBinary(string op : "~")(void delegate(HTML o) @system rhs) @system {
        if (rhs !is null) {
            rhs(this);
        }
    }

    /// ditto
    void opBinary(string op : "~")(void delegate(HTML o) @safe rhs) @safe {
        if (rhs !is null) {
            rhs(this);
        }
    }

    @safe:

    ///
    HTMLTag!"a" a() {
        return typeof(return)(this);
    }
    ///
    HTMLTag!"abbr" abbr() {
        return typeof(return)(this);
    }
    ///
    HTMLTag!"acronym" acronym() {
        return typeof(return)(this);
    }
    ///
    HTMLTag!"address" address() {
        return typeof(return)(this);
    }
    ///
    HTMLTag!"area" area() {
        return typeof(return)(this);
    }
    ///
    HTMLTag!"article" article() {
        return typeof(return)(this);
    }
    ///
    HTMLTag!"aside" aside() {
        return typeof(return)(this);
    }
    ///
    HTMLTag!"audio" audio() {
        return typeof(return)(this);
    }
    ///
    HTMLTag!"b" b() {
        return typeof(return)(this);
    }
    ///
    HTMLTag!"base" base() {
        return typeof(return)(this);
    }
    ///
    HTMLTag!"bdi" bdi() {
        return typeof(return)(this);
    }
    ///
    HTMLTag!"bdo" bdo() {
        return typeof(return)(this);
    }
    ///
    HTMLTag!"big" big() {
        return typeof(return)(this);
    }
    ///
    HTMLTag!"blockquote" blockquote() {
        return typeof(return)(this);
    }
    ///
    HTMLTag!"body" body() {
        return typeof(return)(this);
    }
    ///
    HTMLTag!"br" br() {
        return typeof(return)(this);
    }
    ///
    HTMLTag!"button" button() {
        return typeof(return)(this);
    }
    ///
    HTMLTag!"canvas" canvas() {
        return typeof(return)(this);
    }
    ///
    HTMLTag!"caption" caption() {
        return typeof(return)(this);
    }
    ///
    HTMLTag!"center" center() {
        return typeof(return)(this);
    }
    ///
    HTMLTag!"cite" cite() {
        return typeof(return)(this);
    }
    ///
    HTMLTag!"code" code() {
        return typeof(return)(this);
    }
    ///
    HTMLTag!"col" col() {
        return typeof(return)(this);
    }
    ///
    HTMLTag!"colgroup" colgroup() {
        return typeof(return)(this);
    }
    ///
    HTMLTag!"command" command() {
        return typeof(return)(this);
    }
    ///
    HTMLTag!"data" data() {
        return typeof(return)(this);
    }
    ///
    HTMLTag!"datalist" datalist() {
        return typeof(return)(this);
    }
    ///
    HTMLTag!"dd" dd() {
        return typeof(return)(this);
    }
    ///
    HTMLTag!"del" del() {
        return typeof(return)(this);
    }
    ///
    HTMLTag!"details" details() {
        return typeof(return)(this);
    }
    ///
    HTMLTag!"dfn" dfn() {
        return typeof(return)(this);
    }
    ///
    HTMLTag!"dialog" dialog() {
        return typeof(return)(this);
    }
    ///
    HTMLTag!"dir" dir() {
        return typeof(return)(this);
    }
    ///
    HTMLTag!"div" div() {
        return typeof(return)(this);
    }
    ///
    HTMLTag!"dl" dl() {
        return typeof(return)(this);
    }
    ///
    HTMLTag!"dt" dt() {
        return typeof(return)(this);
    }
    ///
    HTMLTag!"em" em() {
        return typeof(return)(this);
    }
    ///
    HTMLTag!"embed" embed() {
        return typeof(return)(this);
    }
    ///
    HTMLTag!"fencedframe" fencedframe() {
        return typeof(return)(this);
    }
    ///
    HTMLTag!"fieldset" fieldset() {
        return typeof(return)(this);
    }
    ///
    HTMLTag!"figcaption" figcaption() {
        return typeof(return)(this);
    }
    ///
    HTMLTag!"figure" figure() {
        return typeof(return)(this);
    }
    ///
    HTMLTag!"font" font() {
        return typeof(return)(this);
    }
    ///
    HTMLTag!"footer" footer() {
        return typeof(return)(this);
    }
    ///
    HTMLTag!"form" form() {
        return typeof(return)(this);
    }
    ///
    HTMLTag!"frame" frame() {
        return typeof(return)(this);
    }
    ///
    HTMLTag!"frameset" frameset() {
        return typeof(return)(this);
    }
    ///
    HTMLTag!"h1" h1() {
        return typeof(return)(this);
    }
    ///
    HTMLTag!"h2" h2() {
        return typeof(return)(this);
    }
    ///
    HTMLTag!"h3" h3() {
        return typeof(return)(this);
    }
    ///
    HTMLTag!"h4" h4() {
        return typeof(return)(this);
    }
    ///
    HTMLTag!"h5" h5() {
        return typeof(return)(this);
    }
    ///
    HTMLTag!"h6" h6() {
        return typeof(return)(this);
    }
    ///
    HTMLTag!"head" head() {
        return typeof(return)(this);
    }
    ///
    HTMLTag!"header" header() {
        return typeof(return)(this);
    }
    ///
    HTMLTag!"hgroup" hgroup() {
        return typeof(return)(this);
    }
    ///
    HTMLTag!"hr" hr() {
        return typeof(return)(this);
    }
    ///
    HTMLTag!"html" html() {
        return typeof(return)(this);
    }
    ///
    HTMLTag!"i" i() {
        return typeof(return)(this);
    }
    ///
    HTMLTag!"iframe" iframe() {
        return typeof(return)(this);
    }
    ///
    HTMLTag!"img" img() {
        return typeof(return)(this);
    }
    ///
    HTMLTag!"input" input() {
        return typeof(return)(this);
    }
    ///
    HTMLTag!"ins" ins() {
        return typeof(return)(this);
    }
    ///
    HTMLTag!"kbd" kbd() {
        return typeof(return)(this);
    }
    ///
    HTMLTag!"keygen" keygen() {
        return typeof(return)(this);
    }
    ///
    HTMLTag!"label" label() {
        return typeof(return)(this);
    }
    ///
    HTMLTag!"legend" legend() {
        return typeof(return)(this);
    }
    ///
    HTMLTag!"li" li() {
        return typeof(return)(this);
    }
    ///
    HTMLTag!"link" link() {
        return typeof(return)(this);
    }
    ///
    HTMLTag!"main" main() {
        return typeof(return)(this);
    }
    ///
    HTMLTag!"map" map() {
        return typeof(return)(this);
    }
    ///
    HTMLTag!"mark" mark() {
        return typeof(return)(this);
    }
    ///
    HTMLTag!"marquee" marquee() {
        return typeof(return)(this);
    }
    ///
    HTMLTag!"math" math() {
        return typeof(return)(this);
    }
    ///
    HTMLTag!"menu" menu() {
        return typeof(return)(this);
    }
    ///
    HTMLTag!"meta" meta() {
        return typeof(return)(this);
    }
    ///
    HTMLTag!"meter" meter() {
        return typeof(return)(this);
    }
    ///
    HTMLTag!"nav" nav() {
        return typeof(return)(this);
    }
    ///
    HTMLTag!"nobr" nobr() {
        return typeof(return)(this);
    }
    ///
    HTMLTag!"noembed" noembed() {
        return typeof(return)(this);
    }
    ///
    HTMLTag!"noframes" noframes() {
        return typeof(return)(this);
    }
    ///
    HTMLTag!"noscript" noscript() {
        return typeof(return)(this);
    }
    ///
    HTMLTag!"object" object() {
        return typeof(return)(this);
    }
    ///
    HTMLTag!"ol" ol() {
        return typeof(return)(this);
    }
    ///
    HTMLTag!"optgroup" optgroup() {
        return typeof(return)(this);
    }
    ///
    HTMLTag!"option" option() {
        return typeof(return)(this);
    }
    ///
    HTMLTag!"output" output() {
        return typeof(return)(this);
    }
    ///
    HTMLTag!"p" p() {
        return typeof(return)(this);
    }
    ///
    HTMLTag!"param" param() {
        return typeof(return)(this);
    }
    ///
    HTMLTag!"picture" picture() {
        return typeof(return)(this);
    }
    ///
    HTMLTag!"plaintext" plaintext() {
        return typeof(return)(this);
    }
    ///
    HTMLTag!"pre" pre() {
        return typeof(return)(this);
    }
    ///
    HTMLTag!"progress" progress() {
        return typeof(return)(this);
    }
    ///
    HTMLTag!"q" q() {
        return typeof(return)(this);
    }
    ///
    HTMLTag!"rb" rb() {
        return typeof(return)(this);
    }
    ///
    HTMLTag!"rp" rp() {
        return typeof(return)(this);
    }
    ///
    HTMLTag!"rt" rt() {
        return typeof(return)(this);
    }
    ///
    HTMLTag!"rtc" rtc() {
        return typeof(return)(this);
    }
    ///
    HTMLTag!"ruby" ruby() {
        return typeof(return)(this);
    }
    ///
    HTMLTag!"s" s() {
        return typeof(return)(this);
    }
    ///
    HTMLTag!"samp" samp() {
        return typeof(return)(this);
    }
    ///
    HTMLTag!"script" script() {
        return typeof(return)(this);
    }
    ///
    HTMLTag!"search" search() {
        return typeof(return)(this);
    }
    ///
    HTMLTag!"section" section() {
        return typeof(return)(this);
    }
    ///
    HTMLTag!"select" select() {
        return typeof(return)(this);
    }
    ///
    HTMLTag!"slot" slot() {
        return typeof(return)(this);
    }
    ///
    HTMLTag!"small" small() {
        return typeof(return)(this);
    }
    ///
    HTMLTag!"source" source() {
        return typeof(return)(this);
    }
    ///
    HTMLTag!"span" span() {
        return typeof(return)(this);
    }
    ///
    HTMLTag!"strike" strike() {
        return typeof(return)(this);
    }
    ///
    HTMLTag!"strong" strong() {
        return typeof(return)(this);
    }
    ///
    HTMLTag!"style" style() {
        return typeof(return)(this);
    }
    ///
    HTMLTag!"sub" sub() {
        return typeof(return)(this);
    }
    ///
    HTMLTag!"summary" summary() {
        return typeof(return)(this);
    }
    ///
    HTMLTag!"sup" sup() {
        return typeof(return)(this);
    }
    ///
    HTMLTag!"svg" svg() {
        return typeof(return)(this);
    }
    ///
    HTMLTag!"table" table() {
        return typeof(return)(this);
    }
    ///
    HTMLTag!"tbody" tbody() {
        return typeof(return)(this);
    }
    ///
    HTMLTag!"td" td() {
        return typeof(return)(this);
    }
    ///
    HTMLTag!"template" template_() {
        return typeof(return)(this);
    }
    ///
    HTMLTag!"textarea" textarea() {
        return typeof(return)(this);
    }
    ///
    HTMLTag!"tfoot" tfoot() {
        return typeof(return)(this);
    }
    ///
    HTMLTag!"th" th() {
        return typeof(return)(this);
    }
    ///
    HTMLTag!"thead" thead() {
        return typeof(return)(this);
    }
    ///
    HTMLTag!"time" time() {
        return typeof(return)(this);
    }
    ///
    HTMLTag!"title" title() {
        return typeof(return)(this);
    }
    ///
    HTMLTag!"tr" tr() {
        return typeof(return)(this);
    }
    ///
    HTMLTag!"track" track() {
        return typeof(return)(this);
    }
    ///
    HTMLTag!"tt" tt() {
        return typeof(return)(this);
    }
    ///
    HTMLTag!"u" u() {
        return typeof(return)(this);
    }
    ///
    HTMLTag!"ul" ul() {
        return typeof(return)(this);
    }
    ///
    HTMLTag!"var" var() {
        return typeof(return)(this);
    }
    ///
    HTMLTag!"video" video() {
        return typeof(return)(this);
    }
    ///
    HTMLTag!"wbr" wbr() {
        return typeof(return)(this);
    }
    ///
    HTMLTag!"xmp" xmp() {
        return typeof(return)(this);
    }

}