Tag.cs

using ToSic.Razor.Blade;
using ToSic.Razor.Html5;
using ToSic.Razor.Markup;
using ToSic.Razor.Internals;
using ToSic.Razor.Internals.Documentation;
// ****
// ****
// This is auto-generated code - don't modify
// Re-run the generation program to recreate
// Created 20.2.2023. 13:35
//
// Each tag and attributes of it prepare code, and they return an object of the same type again
// to allow fluid chaining of the commands
// ****
// ****
// ReSharper disable PartialTypeWithSinglePart
// ReSharper disable RedundantArgumentDefaultValue
// ReSharper disable InconsistentNaming
// ReSharper disable IdentifierTypo
// ReSharper disable UnusedMember.Global


// ReSharper disable once CheckNamespace
namespace ToSic.Razor.Blade
{
    public static partial class Tag
    {
        
    /// <summary>
    /// Generate a standard HTML5 &lt;a&gt; tag with optional contents
    /// </summary>
    /// <returns>
    /// A A object with all the attributes available in that tag
    /// </returns>
    /// <param name="content">one or more objects (strings or tags) which will be inside the tag</param>
    /// <code>
    /// var a = Tag.A();
    /// var a2 = Tag.A("hello there");
    /// </code>
    public static A A(params object[] content) => new A(content) { IsImmutable = false };

    /// <summary>
    /// Generate a standard HTML5 &lt;abbr&gt; tag with optional contents
    /// </summary>
    /// <returns>
    /// A Abbr object with all the attributes available in that tag
    /// </returns>
    /// <param name="content">one or more objects (strings or tags) which will be inside the tag</param>
    /// <code>
    /// var abbr = Tag.Abbr();
    /// var abbr2 = Tag.Abbr("hello there");
    /// </code>
    public static Abbr Abbr(params object[] content) => new Abbr(content) { IsImmutable = false };

    /// <summary>
    /// Generate a standard HTML5 &lt;address&gt; tag with optional contents
    /// </summary>
    /// <returns>
    /// A Address object with all the attributes available in that tag
    /// </returns>
    /// <param name="content">one or more objects (strings or tags) which will be inside the tag</param>
    /// <code>
    /// var address = Tag.Address();
    /// var address2 = Tag.Address("hello there");
    /// </code>
    public static Address Address(params object[] content) => new Address(content) { IsImmutable = false };

    /// <summary>
    /// Generate a standard HTML5 &lt;area&gt; tag with optional contents
    /// </summary>
    /// <returns>
    /// A Area object with all the attributes available in that tag
    /// </returns>
    /// <param name="content">one or more objects (strings or tags) which will be inside the tag</param>
    /// <code>
    /// var area = Tag.Area();
    /// var area2 = Tag.Area("hello there");
    /// </code>
    public static Area Area(params object[] content) => new Area(content) { IsImmutable = false };

    /// <summary>
    /// Generate a standard HTML5 &lt;article&gt; tag with optional contents
    /// </summary>
    /// <returns>
    /// A Article object with all the attributes available in that tag
    /// </returns>
    /// <param name="content">one or more objects (strings or tags) which will be inside the tag</param>
    /// <code>
    /// var article = Tag.Article();
    /// var article2 = Tag.Article("hello there");
    /// </code>
    public static Article Article(params object[] content) => new Article(content) { IsImmutable = false };

    /// <summary>
    /// Generate a standard HTML5 &lt;aside&gt; tag with optional contents
    /// </summary>
    /// <returns>
    /// A Aside object with all the attributes available in that tag
    /// </returns>
    /// <param name="content">one or more objects (strings or tags) which will be inside the tag</param>
    /// <code>
    /// var aside = Tag.Aside();
    /// var aside2 = Tag.Aside("hello there");
    /// </code>
    public static Aside Aside(params object[] content) => new Aside(content) { IsImmutable = false };

    /// <summary>
    /// Generate a standard HTML5 &lt;audio&gt; tag with optional contents
    /// </summary>
    /// <returns>
    /// A Audio object with all the attributes available in that tag
    /// </returns>
    /// <param name="content">one or more objects (strings or tags) which will be inside the tag</param>
    /// <code>
    /// var audio = Tag.Audio();
    /// var audio2 = Tag.Audio("hello there");
    /// </code>
    public static Audio Audio(params object[] content) => new Audio(content) { IsImmutable = false };

    /// <summary>
    /// Generate a standard HTML5 &lt;b&gt; tag with optional contents
    /// </summary>
    /// <returns>
    /// A B object with all the attributes available in that tag
    /// </returns>
    /// <param name="content">one or more objects (strings or tags) which will be inside the tag</param>
    /// <code>
    /// var b = Tag.B();
    /// var b2 = Tag.B("hello there");
    /// </code>
    public static B B(params object[] content) => new B(content) { IsImmutable = false };

    /// <summary>
    /// Generate a standard HTML5 &lt;base&gt; tag with optional contents
    /// </summary>
    /// <returns>
    /// A Base object with all the attributes available in that tag
    /// </returns>
    /// <param name="content">one or more objects (strings or tags) which will be inside the tag</param>
    /// <code>
    /// var base = Tag.Base();
    /// </code>
    public static Base Base(params object[] content) => new Base(content) { IsImmutable = false };

    /// <summary>
    /// Generate a standard HTML5 &lt;bdi&gt; tag with optional contents
    /// </summary>
    /// <returns>
    /// A Bdi object with all the attributes available in that tag
    /// </returns>
    /// <param name="content">one or more objects (strings or tags) which will be inside the tag</param>
    /// <code>
    /// var bdi = Tag.Bdi();
    /// var bdi2 = Tag.Bdi("hello there");
    /// </code>
    public static Bdi Bdi(params object[] content) => new Bdi(content) { IsImmutable = false };

    /// <summary>
    /// Generate a standard HTML5 &lt;bdo&gt; tag with optional contents
    /// </summary>
    /// <returns>
    /// A Bdo object with all the attributes available in that tag
    /// </returns>
    /// <param name="content">one or more objects (strings or tags) which will be inside the tag</param>
    /// <code>
    /// var bdo = Tag.Bdo();
    /// var bdo2 = Tag.Bdo("hello there");
    /// </code>
    public static Bdo Bdo(params object[] content) => new Bdo(content) { IsImmutable = false };

    /// <summary>
    /// Generate a standard HTML5 &lt;blockquote&gt; tag with optional contents
    /// </summary>
    /// <returns>
    /// A Blockquote object with all the attributes available in that tag
    /// </returns>
    /// <param name="content">one or more objects (strings or tags) which will be inside the tag</param>
    /// <code>
    /// var blockquote = Tag.Blockquote();
    /// var blockquote2 = Tag.Blockquote("hello there");
    /// </code>
    public static Blockquote Blockquote(params object[] content) => new Blockquote(content) { IsImmutable = false };

    /// <summary>
    /// Generate a standard HTML5 &lt;br&gt; tag with optional contents
    /// </summary>
    /// <returns>
    /// A Br object with all the attributes available in that tag
    /// </returns>
    /// <param name="content">one or more objects (strings or tags) which will be inside the tag</param>
    /// <code>
    /// var br = Tag.Br();
    /// </code>
    public static Br Br(params object[] content) => new Br(content) { IsImmutable = false };

    /// <summary>
    /// Generate a standard HTML5 &lt;button&gt; tag with optional contents
    /// </summary>
    /// <returns>
    /// A Button object with all the attributes available in that tag
    /// </returns>
    /// <param name="content">one or more objects (strings or tags) which will be inside the tag</param>
    /// <code>
    /// var button = Tag.Button();
    /// var button2 = Tag.Button("hello there");
    /// </code>
    public static Button Button(params object[] content) => new Button(content) { IsImmutable = false };

    /// <summary>
    /// Generate a standard HTML5 &lt;canvas&gt; tag with optional contents
    /// </summary>
    /// <returns>
    /// A Canvas object with all the attributes available in that tag
    /// </returns>
    /// <param name="content">one or more objects (strings or tags) which will be inside the tag</param>
    /// <code>
    /// var canvas = Tag.Canvas();
    /// var canvas2 = Tag.Canvas("hello there");
    /// </code>
    public static Canvas Canvas(params object[] content) => new Canvas(content) { IsImmutable = false };

    /// <summary>
    /// Generate a standard HTML5 &lt;caption&gt; tag with optional contents
    /// </summary>
    /// <returns>
    /// A Caption object with all the attributes available in that tag
    /// </returns>
    /// <param name="content">one or more objects (strings or tags) which will be inside the tag</param>
    /// <code>
    /// var caption = Tag.Caption();
    /// var caption2 = Tag.Caption("hello there");
    /// </code>
    public static Caption Caption(params object[] content) => new Caption(content) { IsImmutable = false };

    /// <summary>
    /// Generate a standard HTML5 &lt;cite&gt; tag with optional contents
    /// </summary>
    /// <returns>
    /// A Cite object with all the attributes available in that tag
    /// </returns>
    /// <param name="content">one or more objects (strings or tags) which will be inside the tag</param>
    /// <code>
    /// var cite = Tag.Cite();
    /// var cite2 = Tag.Cite("hello there");
    /// </code>
    public static Cite Cite(params object[] content) => new Cite(content) { IsImmutable = false };

    /// <summary>
    /// Generate a standard HTML5 &lt;code&gt; tag with optional contents
    /// </summary>
    /// <returns>
    /// A Code object with all the attributes available in that tag
    /// </returns>
    /// <param name="content">one or more objects (strings or tags) which will be inside the tag</param>
    /// <code>
    /// var code = Tag.Code();
    /// var code2 = Tag.Code("hello there");
    /// </code>
    public static Code Code(params object[] content) => new Code(content) { IsImmutable = false };

    /// <summary>
    /// Generate a standard HTML5 &lt;col&gt; tag with optional contents
    /// </summary>
    /// <returns>
    /// A Col object with all the attributes available in that tag
    /// </returns>
    /// <param name="content">one or more objects (strings or tags) which will be inside the tag</param>
    /// <code>
    /// var col = Tag.Col();
    /// var col2 = Tag.Col("hello there");
    /// </code>
    public static Col Col(params object[] content) => new Col(content) { IsImmutable = false };

    /// <summary>
    /// Generate a standard HTML5 &lt;colgroup&gt; tag with optional contents
    /// </summary>
    /// <returns>
    /// A Colgroup object with all the attributes available in that tag
    /// </returns>
    /// <param name="content">one or more objects (strings or tags) which will be inside the tag</param>
    /// <code>
    /// var colgroup = Tag.Colgroup();
    /// var colgroup2 = Tag.Colgroup("hello there");
    /// </code>
    public static Colgroup Colgroup(params object[] content) => new Colgroup(content) { IsImmutable = false };

    /// <summary>
    /// Generate a standard HTML5 &lt;data&gt; tag with optional contents
    /// </summary>
    /// <returns>
    /// A Data object with all the attributes available in that tag
    /// </returns>
    /// <param name="content">one or more objects (strings or tags) which will be inside the tag</param>
    /// <code>
    /// var data = Tag.Data();
    /// var data2 = Tag.Data("hello there");
    /// </code>
    public static Data Data(params object[] content) => new Data(content) { IsImmutable = false };

    /// <summary>
    /// Generate a standard HTML5 &lt;datalist&gt; tag with optional contents
    /// </summary>
    /// <returns>
    /// A Datalist object with all the attributes available in that tag
    /// </returns>
    /// <param name="content">one or more objects (strings or tags) which will be inside the tag</param>
    /// <code>
    /// var datalist = Tag.Datalist();
    /// var datalist2 = Tag.Datalist("hello there");
    /// </code>
    public static Datalist Datalist(params object[] content) => new Datalist(content) { IsImmutable = false };

    /// <summary>
    /// Generate a standard HTML5 &lt;dd&gt; tag with optional contents
    /// </summary>
    /// <returns>
    /// A Dd object with all the attributes available in that tag
    /// </returns>
    /// <param name="content">one or more objects (strings or tags) which will be inside the tag</param>
    /// <code>
    /// var dd = Tag.Dd();
    /// var dd2 = Tag.Dd("hello there");
    /// </code>
    public static Dd Dd(params object[] content) => new Dd(content) { IsImmutable = false };

    /// <summary>
    /// Generate a standard HTML5 &lt;del&gt; tag with optional contents
    /// </summary>
    /// <returns>
    /// A Del object with all the attributes available in that tag
    /// </returns>
    /// <param name="content">one or more objects (strings or tags) which will be inside the tag</param>
    /// <code>
    /// var del = Tag.Del();
    /// var del2 = Tag.Del("hello there");
    /// </code>
    public static Del Del(params object[] content) => new Del(content) { IsImmutable = false };

    /// <summary>
    /// Generate a standard HTML5 &lt;details&gt; tag with optional contents
    /// </summary>
    /// <returns>
    /// A Details object with all the attributes available in that tag
    /// </returns>
    /// <param name="content">one or more objects (strings or tags) which will be inside the tag</param>
    /// <code>
    /// var details = Tag.Details();
    /// var details2 = Tag.Details("hello there");
    /// </code>
    public static Details Details(params object[] content) => new Details(content) { IsImmutable = false };

    /// <summary>
    /// Generate a standard HTML5 &lt;dfn&gt; tag with optional contents
    /// </summary>
    /// <returns>
    /// A Dfn object with all the attributes available in that tag
    /// </returns>
    /// <param name="content">one or more objects (strings or tags) which will be inside the tag</param>
    /// <code>
    /// var dfn = Tag.Dfn();
    /// var dfn2 = Tag.Dfn("hello there");
    /// </code>
    public static Dfn Dfn(params object[] content) => new Dfn(content) { IsImmutable = false };

    /// <summary>
    /// Generate a standard HTML5 &lt;dialog&gt; tag with optional contents
    /// </summary>
    /// <returns>
    /// A Dialog object with all the attributes available in that tag
    /// </returns>
    /// <param name="content">one or more objects (strings or tags) which will be inside the tag</param>
    /// <code>
    /// var dialog = Tag.Dialog();
    /// var dialog2 = Tag.Dialog("hello there");
    /// </code>
    public static Dialog Dialog(params object[] content) => new Dialog(content) { IsImmutable = false };

    /// <summary>
    /// Generate a standard HTML5 &lt;div&gt; tag with optional contents
    /// </summary>
    /// <returns>
    /// A Div object with all the attributes available in that tag
    /// </returns>
    /// <param name="content">one or more objects (strings or tags) which will be inside the tag</param>
    /// <code>
    /// var div = Tag.Div();
    /// var div2 = Tag.Div("hello there");
    /// </code>
    public static Div Div(params object[] content) => new Div(content) { IsImmutable = false };

    /// <summary>
    /// Generate a standard HTML5 &lt;dl&gt; tag with optional contents
    /// </summary>
    /// <returns>
    /// A Dl object with all the attributes available in that tag
    /// </returns>
    /// <param name="content">one or more objects (strings or tags) which will be inside the tag</param>
    /// <code>
    /// var dl = Tag.Dl();
    /// var dl2 = Tag.Dl("hello there");
    /// </code>
    public static Dl Dl(params object[] content) => new Dl(content) { IsImmutable = false };

    /// <summary>
    /// Generate a standard HTML5 &lt;dt&gt; tag with optional contents
    /// </summary>
    /// <returns>
    /// A Dt object with all the attributes available in that tag
    /// </returns>
    /// <param name="content">one or more objects (strings or tags) which will be inside the tag</param>
    /// <code>
    /// var dt = Tag.Dt();
    /// var dt2 = Tag.Dt("hello there");
    /// </code>
    public static Dt Dt(params object[] content) => new Dt(content) { IsImmutable = false };

    /// <summary>
    /// Generate a standard HTML5 &lt;em&gt; tag with optional contents
    /// </summary>
    /// <returns>
    /// A Em object with all the attributes available in that tag
    /// </returns>
    /// <param name="content">one or more objects (strings or tags) which will be inside the tag</param>
    /// <code>
    /// var em = Tag.Em();
    /// var em2 = Tag.Em("hello there");
    /// </code>
    public static Em Em(params object[] content) => new Em(content) { IsImmutable = false };

    /// <summary>
    /// Generate a standard HTML5 &lt;embed&gt; tag with optional contents
    /// </summary>
    /// <returns>
    /// A Embed object with all the attributes available in that tag
    /// </returns>
    /// <param name="content">one or more objects (strings or tags) which will be inside the tag</param>
    /// <code>
    /// var embed = Tag.Embed();
    /// var embed2 = Tag.Embed("hello there");
    /// </code>
    public static Embed Embed(params object[] content) => new Embed(content) { IsImmutable = false };

    /// <summary>
    /// Generate a standard HTML5 &lt;fieldset&gt; tag with optional contents
    /// </summary>
    /// <returns>
    /// A Fieldset object with all the attributes available in that tag
    /// </returns>
    /// <param name="content">one or more objects (strings or tags) which will be inside the tag</param>
    /// <code>
    /// var fieldset = Tag.Fieldset();
    /// var fieldset2 = Tag.Fieldset("hello there");
    /// </code>
    public static Fieldset Fieldset(params object[] content) => new Fieldset(content) { IsImmutable = false };

    /// <summary>
    /// Generate a standard HTML5 &lt;figcaption&gt; tag with optional contents
    /// </summary>
    /// <returns>
    /// A Figcaption object with all the attributes available in that tag
    /// </returns>
    /// <param name="content">one or more objects (strings or tags) which will be inside the tag</param>
    /// <code>
    /// var figcaption = Tag.Figcaption();
    /// var figcaption2 = Tag.Figcaption("hello there");
    /// </code>
    public static Figcaption Figcaption(params object[] content) => new Figcaption(content) { IsImmutable = false };

    /// <summary>
    /// Generate a standard HTML5 &lt;figure&gt; tag with optional contents
    /// </summary>
    /// <returns>
    /// A Figure object with all the attributes available in that tag
    /// </returns>
    /// <param name="content">one or more objects (strings or tags) which will be inside the tag</param>
    /// <code>
    /// var figure = Tag.Figure();
    /// var figure2 = Tag.Figure("hello there");
    /// </code>
    public static Figure Figure(params object[] content) => new Figure(content) { IsImmutable = false };

    /// <summary>
    /// Generate a standard HTML5 &lt;footer&gt; tag with optional contents
    /// </summary>
    /// <returns>
    /// A Footer object with all the attributes available in that tag
    /// </returns>
    /// <param name="content">one or more objects (strings or tags) which will be inside the tag</param>
    /// <code>
    /// var footer = Tag.Footer();
    /// var footer2 = Tag.Footer("hello there");
    /// </code>
    public static Footer Footer(params object[] content) => new Footer(content) { IsImmutable = false };

    /// <summary>
    /// Generate a standard HTML5 &lt;form&gt; tag with optional contents
    /// </summary>
    /// <returns>
    /// A Form object with all the attributes available in that tag
    /// </returns>
    /// <param name="content">one or more objects (strings or tags) which will be inside the tag</param>
    /// <code>
    /// var form = Tag.Form();
    /// var form2 = Tag.Form("hello there");
    /// </code>
    public static Form Form(params object[] content) => new Form(content) { IsImmutable = false };

    /// <summary>
    /// Generate a standard HTML5 &lt;h1&gt; tag with optional contents
    /// </summary>
    /// <returns>
    /// A H1 object with all the attributes available in that tag
    /// </returns>
    /// <param name="content">one or more objects (strings or tags) which will be inside the tag</param>
    /// <code>
    /// var h1 = Tag.H1();
    /// var h12 = Tag.H1("hello there");
    /// </code>
    public static H1 H1(params object[] content) => new H1(content) { IsImmutable = false };

    /// <summary>
    /// Generate a standard HTML5 &lt;h2&gt; tag with optional contents
    /// </summary>
    /// <returns>
    /// A H2 object with all the attributes available in that tag
    /// </returns>
    /// <param name="content">one or more objects (strings or tags) which will be inside the tag</param>
    /// <code>
    /// var h2 = Tag.H2();
    /// var h22 = Tag.H2("hello there");
    /// </code>
    public static H2 H2(params object[] content) => new H2(content) { IsImmutable = false };

    /// <summary>
    /// Generate a standard HTML5 &lt;h3&gt; tag with optional contents
    /// </summary>
    /// <returns>
    /// A H3 object with all the attributes available in that tag
    /// </returns>
    /// <param name="content">one or more objects (strings or tags) which will be inside the tag</param>
    /// <code>
    /// var h3 = Tag.H3();
    /// var h32 = Tag.H3("hello there");
    /// </code>
    public static H3 H3(params object[] content) => new H3(content) { IsImmutable = false };

    /// <summary>
    /// Generate a standard HTML5 &lt;h4&gt; tag with optional contents
    /// </summary>
    /// <returns>
    /// A H4 object with all the attributes available in that tag
    /// </returns>
    /// <param name="content">one or more objects (strings or tags) which will be inside the tag</param>
    /// <code>
    /// var h4 = Tag.H4();
    /// var h42 = Tag.H4("hello there");
    /// </code>
    public static H4 H4(params object[] content) => new H4(content) { IsImmutable = false };

    /// <summary>
    /// Generate a standard HTML5 &lt;h5&gt; tag with optional contents
    /// </summary>
    /// <returns>
    /// A H5 object with all the attributes available in that tag
    /// </returns>
    /// <param name="content">one or more objects (strings or tags) which will be inside the tag</param>
    /// <code>
    /// var h5 = Tag.H5();
    /// var h52 = Tag.H5("hello there");
    /// </code>
    public static H5 H5(params object[] content) => new H5(content) { IsImmutable = false };

    /// <summary>
    /// Generate a standard HTML5 &lt;h6&gt; tag with optional contents
    /// </summary>
    /// <returns>
    /// A H6 object with all the attributes available in that tag
    /// </returns>
    /// <param name="content">one or more objects (strings or tags) which will be inside the tag</param>
    /// <code>
    /// var h6 = Tag.H6();
    /// var h62 = Tag.H6("hello there");
    /// </code>
    public static H6 H6(params object[] content) => new H6(content) { IsImmutable = false };

    /// <summary>
    /// Generate a standard HTML5 &lt;head&gt; tag with optional contents
    /// </summary>
    /// <returns>
    /// A Head object with all the attributes available in that tag
    /// </returns>
    /// <param name="content">one or more objects (strings or tags) which will be inside the tag</param>
    /// <code>
    /// var head = Tag.Head();
    /// var head2 = Tag.Head("hello there");
    /// </code>
    public static Head Head(params object[] content) => new Head(content) { IsImmutable = false };

    /// <summary>
    /// Generate a standard HTML5 &lt;header&gt; tag with optional contents
    /// </summary>
    /// <returns>
    /// A Header object with all the attributes available in that tag
    /// </returns>
    /// <param name="content">one or more objects (strings or tags) which will be inside the tag</param>
    /// <code>
    /// var header = Tag.Header();
    /// var header2 = Tag.Header("hello there");
    /// </code>
    public static Header Header(params object[] content) => new Header(content) { IsImmutable = false };

    /// <summary>
    /// Generate a standard HTML5 &lt;hr&gt; tag with optional contents
    /// </summary>
    /// <returns>
    /// A Hr object with all the attributes available in that tag
    /// </returns>
    /// <param name="content">one or more objects (strings or tags) which will be inside the tag</param>
    /// <code>
    /// var hr = Tag.Hr();
    /// </code>
    public static Hr Hr(params object[] content) => new Hr(content) { IsImmutable = false };

    /// <summary>
    /// Generate a standard HTML5 &lt;i&gt; tag with optional contents
    /// </summary>
    /// <returns>
    /// A I object with all the attributes available in that tag
    /// </returns>
    /// <param name="content">one or more objects (strings or tags) which will be inside the tag</param>
    /// <code>
    /// var i = Tag.I();
    /// var i2 = Tag.I("hello there");
    /// </code>
    public static I I(params object[] content) => new I(content) { IsImmutable = false };

    /// <summary>
    /// Generate a standard HTML5 &lt;iframe&gt; tag with optional contents
    /// </summary>
    /// <returns>
    /// A Iframe object with all the attributes available in that tag
    /// </returns>
    /// <param name="content">one or more objects (strings or tags) which will be inside the tag</param>
    /// <code>
    /// var iframe = Tag.Iframe();
    /// </code>
    public static Iframe Iframe(params object[] content) => new Iframe(content) { IsImmutable = false };

    /// <summary>
    /// Generate a standard HTML5 &lt;img&gt; tag with optional contents
    /// </summary>
    /// <returns>
    /// A Img object with all the attributes available in that tag
    /// </returns>
    /// <param name="content">one or more objects (strings or tags) which will be inside the tag</param>
    /// <code>
    /// var img = Tag.Img();
    /// </code>
    public static Img Img(params object[] content) => new Img(content) { IsImmutable = false };

    /// <summary>
    /// Generate a standard HTML5 &lt;input&gt; tag with optional contents
    /// </summary>
    /// <returns>
    /// A Input object with all the attributes available in that tag
    /// </returns>
    /// <param name="content">one or more objects (strings or tags) which will be inside the tag</param>
    /// <code>
    /// var input = Tag.Input();
    /// </code>
    public static Input Input(params object[] content) => new Input(content) { IsImmutable = false };

    /// <summary>
    /// Generate a standard HTML5 &lt;ins&gt; tag with optional contents
    /// </summary>
    /// <returns>
    /// A Ins object with all the attributes available in that tag
    /// </returns>
    /// <param name="content">one or more objects (strings or tags) which will be inside the tag</param>
    /// <code>
    /// var ins = Tag.Ins();
    /// var ins2 = Tag.Ins("hello there");
    /// </code>
    public static Ins Ins(params object[] content) => new Ins(content) { IsImmutable = false };

    /// <summary>
    /// Generate a standard HTML5 &lt;kbd&gt; tag with optional contents
    /// </summary>
    /// <returns>
    /// A Kbd object with all the attributes available in that tag
    /// </returns>
    /// <param name="content">one or more objects (strings or tags) which will be inside the tag</param>
    /// <code>
    /// var kbd = Tag.Kbd();
    /// var kbd2 = Tag.Kbd("hello there");
    /// </code>
    public static Kbd Kbd(params object[] content) => new Kbd(content) { IsImmutable = false };

    /// <summary>
    /// Generate a standard HTML5 &lt;label&gt; tag with optional contents
    /// </summary>
    /// <returns>
    /// A Label object with all the attributes available in that tag
    /// </returns>
    /// <param name="content">one or more objects (strings or tags) which will be inside the tag</param>
    /// <code>
    /// var label = Tag.Label();
    /// var label2 = Tag.Label("hello there");
    /// </code>
    public static Label Label(params object[] content) => new Label(content) { IsImmutable = false };

    /// <summary>
    /// Generate a standard HTML5 &lt;legend&gt; tag with optional contents
    /// </summary>
    /// <returns>
    /// A Legend object with all the attributes available in that tag
    /// </returns>
    /// <param name="content">one or more objects (strings or tags) which will be inside the tag</param>
    /// <code>
    /// var legend = Tag.Legend();
    /// var legend2 = Tag.Legend("hello there");
    /// </code>
    public static Legend Legend(params object[] content) => new Legend(content) { IsImmutable = false };

    /// <summary>
    /// Generate a standard HTML5 &lt;li&gt; tag with optional contents
    /// </summary>
    /// <returns>
    /// A Li object with all the attributes available in that tag
    /// </returns>
    /// <param name="content">one or more objects (strings or tags) which will be inside the tag</param>
    /// <code>
    /// var li = Tag.Li();
    /// var li2 = Tag.Li("hello there");
    /// </code>
    public static Li Li(params object[] content) => new Li(content) { IsImmutable = false };

    /// <summary>
    /// Generate a standard HTML5 &lt;link&gt; tag with optional contents
    /// </summary>
    /// <returns>
    /// A Link object with all the attributes available in that tag
    /// </returns>
    /// <param name="content">one or more objects (strings or tags) which will be inside the tag</param>
    /// <code>
    /// var link = Tag.Link();
    /// </code>
    public static Link Link(params object[] content) => new Link(content) { IsImmutable = false };

    /// <summary>
    /// Generate a standard HTML5 &lt;main&gt; tag with optional contents
    /// </summary>
    /// <returns>
    /// A Main object with all the attributes available in that tag
    /// </returns>
    /// <param name="content">one or more objects (strings or tags) which will be inside the tag</param>
    /// <code>
    /// var main = Tag.Main();
    /// var main2 = Tag.Main("hello there");
    /// </code>
    public static Main Main(params object[] content) => new Main(content) { IsImmutable = false };

    /// <summary>
    /// Generate a standard HTML5 &lt;map&gt; tag with optional contents
    /// </summary>
    /// <returns>
    /// A Map object with all the attributes available in that tag
    /// </returns>
    /// <param name="content">one or more objects (strings or tags) which will be inside the tag</param>
    /// <code>
    /// var map = Tag.Map();
    /// var map2 = Tag.Map("hello there");
    /// </code>
    public static Map Map(params object[] content) => new Map(content) { IsImmutable = false };

    /// <summary>
    /// Generate a standard HTML5 &lt;mark&gt; tag with optional contents
    /// </summary>
    /// <returns>
    /// A Mark object with all the attributes available in that tag
    /// </returns>
    /// <param name="content">one or more objects (strings or tags) which will be inside the tag</param>
    /// <code>
    /// var mark = Tag.Mark();
    /// var mark2 = Tag.Mark("hello there");
    /// </code>
    public static Mark Mark(params object[] content) => new Mark(content) { IsImmutable = false };

    /// <summary>
    /// Generate a standard HTML5 &lt;meta&gt; tag with optional contents
    /// </summary>
    /// <returns>
    /// A Meta object with all the attributes available in that tag
    /// </returns>
    /// <param name="content">one or more objects (strings or tags) which will be inside the tag</param>
    /// <code>
    /// var meta = Tag.Meta();
    /// </code>
    public static Meta Meta(params object[] content) => new Meta(content) { IsImmutable = false };

    /// <summary>
    /// Generate a standard HTML5 &lt;meter&gt; tag with optional contents
    /// </summary>
    /// <returns>
    /// A Meter object with all the attributes available in that tag
    /// </returns>
    /// <param name="content">one or more objects (strings or tags) which will be inside the tag</param>
    /// <code>
    /// var meter = Tag.Meter();
    /// var meter2 = Tag.Meter("hello there");
    /// </code>
    public static Meter Meter(params object[] content) => new Meter(content) { IsImmutable = false };

    /// <summary>
    /// Generate a standard HTML5 &lt;nav&gt; tag with optional contents
    /// </summary>
    /// <returns>
    /// A Nav object with all the attributes available in that tag
    /// </returns>
    /// <param name="content">one or more objects (strings or tags) which will be inside the tag</param>
    /// <code>
    /// var nav = Tag.Nav();
    /// var nav2 = Tag.Nav("hello there");
    /// </code>
    public static Nav Nav(params object[] content) => new Nav(content) { IsImmutable = false };

    /// <summary>
    /// Generate a standard HTML5 &lt;noscript&gt; tag with optional contents
    /// </summary>
    /// <returns>
    /// A Noscript object with all the attributes available in that tag
    /// </returns>
    /// <param name="content">one or more objects (strings or tags) which will be inside the tag</param>
    /// <code>
    /// var noscript = Tag.Noscript();
    /// var noscript2 = Tag.Noscript("hello there");
    /// </code>
    public static Noscript Noscript(params object[] content) => new Noscript(content) { IsImmutable = false };

    /// <summary>
    /// Generate a standard HTML5 &lt;object&gt; tag with optional contents
    /// </summary>
    /// <returns>
    /// A Object object with all the attributes available in that tag
    /// </returns>
    /// <param name="content">one or more objects (strings or tags) which will be inside the tag</param>
    /// <code>
    /// var object = Tag.Object();
    /// var object2 = Tag.Object("hello there");
    /// </code>
    public static Object Object(params object[] content) => new Object(content) { IsImmutable = false };

    /// <summary>
    /// Generate a standard HTML5 &lt;ol&gt; tag with optional contents
    /// </summary>
    /// <returns>
    /// A Ol object with all the attributes available in that tag
    /// </returns>
    /// <param name="content">one or more objects (strings or tags) which will be inside the tag</param>
    /// <code>
    /// var ol = Tag.Ol();
    /// var ol2 = Tag.Ol("hello there");
    /// </code>
    public static Ol Ol(params object[] content) => new Ol(content) { IsImmutable = false };

    /// <summary>
    /// Generate a standard HTML5 &lt;optgroup&gt; tag with optional contents
    /// </summary>
    /// <returns>
    /// A Optgroup object with all the attributes available in that tag
    /// </returns>
    /// <param name="content">one or more objects (strings or tags) which will be inside the tag</param>
    /// <code>
    /// var optgroup = Tag.Optgroup();
    /// var optgroup2 = Tag.Optgroup("hello there");
    /// </code>
    public static Optgroup Optgroup(params object[] content) => new Optgroup(content) { IsImmutable = false };

    /// <summary>
    /// Generate a standard HTML5 &lt;option&gt; tag with optional contents
    /// </summary>
    /// <returns>
    /// A Option object with all the attributes available in that tag
    /// </returns>
    /// <param name="content">one or more objects (strings or tags) which will be inside the tag</param>
    /// <code>
    /// var option = Tag.Option();
    /// var option2 = Tag.Option("hello there");
    /// </code>
    public static Option Option(params object[] content) => new Option(content) { IsImmutable = false };

    /// <summary>
    /// Generate a standard HTML5 &lt;output&gt; tag with optional contents
    /// </summary>
    /// <returns>
    /// A Output object with all the attributes available in that tag
    /// </returns>
    /// <param name="content">one or more objects (strings or tags) which will be inside the tag</param>
    /// <code>
    /// var output = Tag.Output();
    /// var output2 = Tag.Output("hello there");
    /// </code>
    public static Output Output(params object[] content) => new Output(content) { IsImmutable = false };

    /// <summary>
    /// Generate a standard HTML5 &lt;p&gt; tag with optional contents
    /// </summary>
    /// <returns>
    /// A P object with all the attributes available in that tag
    /// </returns>
    /// <param name="content">one or more objects (strings or tags) which will be inside the tag</param>
    /// <code>
    /// var p = Tag.P();
    /// var p2 = Tag.P("hello there");
    /// </code>
    public static P P(params object[] content) => new P(content) { IsImmutable = false };

    /// <summary>
    /// Generate a standard HTML5 &lt;param&gt; tag with optional contents
    /// </summary>
    /// <returns>
    /// A Param object with all the attributes available in that tag
    /// </returns>
    /// <param name="content">one or more objects (strings or tags) which will be inside the tag</param>
    /// <code>
    /// var param = Tag.Param();
    /// var param2 = Tag.Param("hello there");
    /// </code>
    public static Param Param(params object[] content) => new Param(content) { IsImmutable = false };

    /// <summary>
    /// Generate a standard HTML5 &lt;picture&gt; tag with optional contents
    /// </summary>
    /// <returns>
    /// A Picture object with all the attributes available in that tag
    /// </returns>
    /// <param name="content">one or more objects (strings or tags) which will be inside the tag</param>
    /// <code>
    /// var picture = Tag.Picture();
    /// var picture2 = Tag.Picture("hello there");
    /// </code>
    public static Picture Picture(params object[] content) => new Picture(content) { IsImmutable = false };

    /// <summary>
    /// Generate a standard HTML5 &lt;pre&gt; tag with optional contents
    /// </summary>
    /// <returns>
    /// A Pre object with all the attributes available in that tag
    /// </returns>
    /// <param name="content">one or more objects (strings or tags) which will be inside the tag</param>
    /// <code>
    /// var pre = Tag.Pre();
    /// var pre2 = Tag.Pre("hello there");
    /// </code>
    public static Pre Pre(params object[] content) => new Pre(content) { IsImmutable = false };

    /// <summary>
    /// Generate a standard HTML5 &lt;progress&gt; tag with optional contents
    /// </summary>
    /// <returns>
    /// A Progress object with all the attributes available in that tag
    /// </returns>
    /// <param name="content">one or more objects (strings or tags) which will be inside the tag</param>
    /// <code>
    /// var progress = Tag.Progress();
    /// var progress2 = Tag.Progress("hello there");
    /// </code>
    public static Progress Progress(params object[] content) => new Progress(content) { IsImmutable = false };

    /// <summary>
    /// Generate a standard HTML5 &lt;q&gt; tag with optional contents
    /// </summary>
    /// <returns>
    /// A Q object with all the attributes available in that tag
    /// </returns>
    /// <param name="content">one or more objects (strings or tags) which will be inside the tag</param>
    /// <code>
    /// var q = Tag.Q();
    /// var q2 = Tag.Q("hello there");
    /// </code>
    public static Q Q(params object[] content) => new Q(content) { IsImmutable = false };

    /// <summary>
    /// Generate a standard HTML5 &lt;rp&gt; tag with optional contents
    /// </summary>
    /// <returns>
    /// A Rp object with all the attributes available in that tag
    /// </returns>
    /// <param name="content">one or more objects (strings or tags) which will be inside the tag</param>
    /// <code>
    /// var rp = Tag.Rp();
    /// var rp2 = Tag.Rp("hello there");
    /// </code>
    public static Rp Rp(params object[] content) => new Rp(content) { IsImmutable = false };

    /// <summary>
    /// Generate a standard HTML5 &lt;rt&gt; tag with optional contents
    /// </summary>
    /// <returns>
    /// A Rt object with all the attributes available in that tag
    /// </returns>
    /// <param name="content">one or more objects (strings or tags) which will be inside the tag</param>
    /// <code>
    /// var rt = Tag.Rt();
    /// var rt2 = Tag.Rt("hello there");
    /// </code>
    public static Rt Rt(params object[] content) => new Rt(content) { IsImmutable = false };

    /// <summary>
    /// Generate a standard HTML5 &lt;ruby&gt; tag with optional contents
    /// </summary>
    /// <returns>
    /// A Ruby object with all the attributes available in that tag
    /// </returns>
    /// <param name="content">one or more objects (strings or tags) which will be inside the tag</param>
    /// <code>
    /// var ruby = Tag.Ruby();
    /// var ruby2 = Tag.Ruby("hello there");
    /// </code>
    public static Ruby Ruby(params object[] content) => new Ruby(content) { IsImmutable = false };

    /// <summary>
    /// Generate a standard HTML5 &lt;s&gt; tag with optional contents
    /// </summary>
    /// <returns>
    /// A S object with all the attributes available in that tag
    /// </returns>
    /// <param name="content">one or more objects (strings or tags) which will be inside the tag</param>
    /// <code>
    /// var s = Tag.S();
    /// var s2 = Tag.S("hello there");
    /// </code>
    public static S S(params object[] content) => new S(content) { IsImmutable = false };

    /// <summary>
    /// Generate a standard HTML5 &lt;samp&gt; tag with optional contents
    /// </summary>
    /// <returns>
    /// A Samp object with all the attributes available in that tag
    /// </returns>
    /// <param name="content">one or more objects (strings or tags) which will be inside the tag</param>
    /// <code>
    /// var samp = Tag.Samp();
    /// var samp2 = Tag.Samp("hello there");
    /// </code>
    public static Samp Samp(params object[] content) => new Samp(content) { IsImmutable = false };

    /// <summary>
    /// Generate a standard HTML5 &lt;script&gt; tag with optional contents
    /// </summary>
    /// <returns>
    /// A Script object with all the attributes available in that tag
    /// </returns>
    /// <param name="content">one or more objects (strings or tags) which will be inside the tag</param>
    /// <code>
    /// var script = Tag.Script();
    /// var script2 = Tag.Script("hello there");
    /// </code>
    public static Script Script(params object[] content) => new Script(content) { IsImmutable = false };

    /// <summary>
    /// Generate a standard HTML5 &lt;section&gt; tag with optional contents
    /// </summary>
    /// <returns>
    /// A Section object with all the attributes available in that tag
    /// </returns>
    /// <param name="content">one or more objects (strings or tags) which will be inside the tag</param>
    /// <code>
    /// var section = Tag.Section();
    /// var section2 = Tag.Section("hello there");
    /// </code>
    public static Section Section(params object[] content) => new Section(content) { IsImmutable = false };

    /// <summary>
    /// Generate a standard HTML5 &lt;select&gt; tag with optional contents
    /// </summary>
    /// <returns>
    /// A Select object with all the attributes available in that tag
    /// </returns>
    /// <param name="content">one or more objects (strings or tags) which will be inside the tag</param>
    /// <code>
    /// var select = Tag.Select();
    /// var select2 = Tag.Select("hello there");
    /// </code>
    public static Select Select(params object[] content) => new Select(content) { IsImmutable = false };

    /// <summary>
    /// Generate a standard HTML5 &lt;small&gt; tag with optional contents
    /// </summary>
    /// <returns>
    /// A Small object with all the attributes available in that tag
    /// </returns>
    /// <param name="content">one or more objects (strings or tags) which will be inside the tag</param>
    /// <code>
    /// var small = Tag.Small();
    /// var small2 = Tag.Small("hello there");
    /// </code>
    public static Small Small(params object[] content) => new Small(content) { IsImmutable = false };

    /// <summary>
    /// Generate a standard HTML5 &lt;source&gt; tag with optional contents
    /// </summary>
    /// <returns>
    /// A Source object with all the attributes available in that tag
    /// </returns>
    /// <param name="content">one or more objects (strings or tags) which will be inside the tag</param>
    /// <code>
    /// var source = Tag.Source();
    /// </code>
    public static Source Source(params object[] content) => new Source(content) { IsImmutable = false };

    /// <summary>
    /// Generate a standard HTML5 &lt;span&gt; tag with optional contents
    /// </summary>
    /// <returns>
    /// A Span object with all the attributes available in that tag
    /// </returns>
    /// <param name="content">one or more objects (strings or tags) which will be inside the tag</param>
    /// <code>
    /// var span = Tag.Span();
    /// var span2 = Tag.Span("hello there");
    /// </code>
    public static Span Span(params object[] content) => new Span(content) { IsImmutable = false };

    /// <summary>
    /// Generate a standard HTML5 &lt;strong&gt; tag with optional contents
    /// </summary>
    /// <returns>
    /// A Strong object with all the attributes available in that tag
    /// </returns>
    /// <param name="content">one or more objects (strings or tags) which will be inside the tag</param>
    /// <code>
    /// var strong = Tag.Strong();
    /// var strong2 = Tag.Strong("hello there");
    /// </code>
    public static Strong Strong(params object[] content) => new Strong(content) { IsImmutable = false };

    /// <summary>
    /// Generate a standard HTML5 &lt;style&gt; tag with optional contents
    /// </summary>
    /// <returns>
    /// A Style object with all the attributes available in that tag
    /// </returns>
    /// <param name="content">one or more objects (strings or tags) which will be inside the tag</param>
    /// <code>
    /// var style = Tag.Style();
    /// var style2 = Tag.Style("hello there");
    /// </code>
    public static Style Style(params object[] content) => new Style(content) { IsImmutable = false };

    /// <summary>
    /// Generate a standard HTML5 &lt;sub&gt; tag with optional contents
    /// </summary>
    /// <returns>
    /// A Sub object with all the attributes available in that tag
    /// </returns>
    /// <param name="content">one or more objects (strings or tags) which will be inside the tag</param>
    /// <code>
    /// var sub = Tag.Sub();
    /// var sub2 = Tag.Sub("hello there");
    /// </code>
    public static Sub Sub(params object[] content) => new Sub(content) { IsImmutable = false };

    /// <summary>
    /// Generate a standard HTML5 &lt;summary&gt; tag with optional contents
    /// </summary>
    /// <returns>
    /// A Summary object with all the attributes available in that tag
    /// </returns>
    /// <param name="content">one or more objects (strings or tags) which will be inside the tag</param>
    /// <code>
    /// var summary = Tag.Summary();
    /// var summary2 = Tag.Summary("hello there");
    /// </code>
    public static Summary Summary(params object[] content) => new Summary(content) { IsImmutable = false };

    /// <summary>
    /// Generate a standard HTML5 &lt;sup&gt; tag with optional contents
    /// </summary>
    /// <returns>
    /// A Sup object with all the attributes available in that tag
    /// </returns>
    /// <param name="content">one or more objects (strings or tags) which will be inside the tag</param>
    /// <code>
    /// var sup = Tag.Sup();
    /// var sup2 = Tag.Sup("hello there");
    /// </code>
    public static Sup Sup(params object[] content) => new Sup(content) { IsImmutable = false };

    /// <summary>
    /// Generate a standard HTML5 &lt;svg&gt; tag with optional contents
    /// </summary>
    /// <returns>
    /// A Svg object with all the attributes available in that tag
    /// </returns>
    /// <param name="content">one or more objects (strings or tags) which will be inside the tag</param>
    /// <code>
    /// var svg = Tag.Svg();
    /// var svg2 = Tag.Svg("hello there");
    /// </code>
    public static Svg Svg(params object[] content) => new Svg(content) { IsImmutable = false };

    /// <summary>
    /// Generate a standard HTML5 &lt;table&gt; tag with optional contents
    /// </summary>
    /// <returns>
    /// A Table object with all the attributes available in that tag
    /// </returns>
    /// <param name="content">one or more objects (strings or tags) which will be inside the tag</param>
    /// <code>
    /// var table = Tag.Table();
    /// var table2 = Tag.Table("hello there");
    /// </code>
    public static Table Table(params object[] content) => new Table(content) { IsImmutable = false };

    /// <summary>
    /// Generate a standard HTML5 &lt;tbody&gt; tag with optional contents
    /// </summary>
    /// <returns>
    /// A Tbody object with all the attributes available in that tag
    /// </returns>
    /// <param name="content">one or more objects (strings or tags) which will be inside the tag</param>
    /// <code>
    /// var tbody = Tag.Tbody();
    /// var tbody2 = Tag.Tbody("hello there");
    /// </code>
    public static Tbody Tbody(params object[] content) => new Tbody(content) { IsImmutable = false };

    /// <summary>
    /// Generate a standard HTML5 &lt;td&gt; tag with optional contents
    /// </summary>
    /// <returns>
    /// A Td object with all the attributes available in that tag
    /// </returns>
    /// <param name="content">one or more objects (strings or tags) which will be inside the tag</param>
    /// <code>
    /// var td = Tag.Td();
    /// var td2 = Tag.Td("hello there");
    /// </code>
    public static Td Td(params object[] content) => new Td(content) { IsImmutable = false };

    /// <summary>
    /// Generate a standard HTML5 &lt;template&gt; tag with optional contents
    /// </summary>
    /// <returns>
    /// A Template object with all the attributes available in that tag
    /// </returns>
    /// <param name="content">one or more objects (strings or tags) which will be inside the tag</param>
    /// <code>
    /// var template = Tag.Template();
    /// var template2 = Tag.Template("hello there");
    /// </code>
    public static Template Template(params object[] content) => new Template(content) { IsImmutable = false };

    /// <summary>
    /// Generate a standard HTML5 &lt;textarea&gt; tag with optional contents
    /// </summary>
    /// <returns>
    /// A Textarea object with all the attributes available in that tag
    /// </returns>
    /// <param name="content">one or more objects (strings or tags) which will be inside the tag</param>
    /// <code>
    /// var textarea = Tag.Textarea();
    /// var textarea2 = Tag.Textarea("hello there");
    /// </code>
    public static Textarea Textarea(params object[] content) => new Textarea(content) { IsImmutable = false };

    /// <summary>
    /// Generate a standard HTML5 &lt;tfoot&gt; tag with optional contents
    /// </summary>
    /// <returns>
    /// A Tfoot object with all the attributes available in that tag
    /// </returns>
    /// <param name="content">one or more objects (strings or tags) which will be inside the tag</param>
    /// <code>
    /// var tfoot = Tag.Tfoot();
    /// var tfoot2 = Tag.Tfoot("hello there");
    /// </code>
    public static Tfoot Tfoot(params object[] content) => new Tfoot(content) { IsImmutable = false };

    /// <summary>
    /// Generate a standard HTML5 &lt;th&gt; tag with optional contents
    /// </summary>
    /// <returns>
    /// A Th object with all the attributes available in that tag
    /// </returns>
    /// <param name="content">one or more objects (strings or tags) which will be inside the tag</param>
    /// <code>
    /// var th = Tag.Th();
    /// var th2 = Tag.Th("hello there");
    /// </code>
    public static Th Th(params object[] content) => new Th(content) { IsImmutable = false };

    /// <summary>
    /// Generate a standard HTML5 &lt;thead&gt; tag with optional contents
    /// </summary>
    /// <returns>
    /// A Thead object with all the attributes available in that tag
    /// </returns>
    /// <param name="content">one or more objects (strings or tags) which will be inside the tag</param>
    /// <code>
    /// var thead = Tag.Thead();
    /// var thead2 = Tag.Thead("hello there");
    /// </code>
    public static Thead Thead(params object[] content) => new Thead(content) { IsImmutable = false };

    /// <summary>
    /// Generate a standard HTML5 &lt;time&gt; tag with optional contents
    /// </summary>
    /// <returns>
    /// A Time object with all the attributes available in that tag
    /// </returns>
    /// <param name="content">one or more objects (strings or tags) which will be inside the tag</param>
    /// <code>
    /// var time = Tag.Time();
    /// var time2 = Tag.Time("hello there");
    /// </code>
    public static Time Time(params object[] content) => new Time(content) { IsImmutable = false };

    /// <summary>
    /// Generate a standard HTML5 &lt;tr&gt; tag with optional contents
    /// </summary>
    /// <returns>
    /// A Tr object with all the attributes available in that tag
    /// </returns>
    /// <param name="content">one or more objects (strings or tags) which will be inside the tag</param>
    /// <code>
    /// var tr = Tag.Tr();
    /// var tr2 = Tag.Tr("hello there");
    /// </code>
    public static Tr Tr(params object[] content) => new Tr(content) { IsImmutable = false };

    /// <summary>
    /// Generate a standard HTML5 &lt;track&gt; tag with optional contents
    /// </summary>
    /// <returns>
    /// A Track object with all the attributes available in that tag
    /// </returns>
    /// <param name="content">one or more objects (strings or tags) which will be inside the tag</param>
    /// <code>
    /// var track = Tag.Track();
    /// </code>
    public static Track Track(params object[] content) => new Track(content) { IsImmutable = false };

    /// <summary>
    /// Generate a standard HTML5 &lt;u&gt; tag with optional contents
    /// </summary>
    /// <returns>
    /// A U object with all the attributes available in that tag
    /// </returns>
    /// <param name="content">one or more objects (strings or tags) which will be inside the tag</param>
    /// <code>
    /// var u = Tag.U();
    /// var u2 = Tag.U("hello there");
    /// </code>
    public static U U(params object[] content) => new U(content) { IsImmutable = false };

    /// <summary>
    /// Generate a standard HTML5 &lt;ul&gt; tag with optional contents
    /// </summary>
    /// <returns>
    /// A Ul object with all the attributes available in that tag
    /// </returns>
    /// <param name="content">one or more objects (strings or tags) which will be inside the tag</param>
    /// <code>
    /// var ul = Tag.Ul();
    /// var ul2 = Tag.Ul("hello there");
    /// </code>
    public static Ul Ul(params object[] content) => new Ul(content) { IsImmutable = false };

    /// <summary>
    /// Generate a standard HTML5 &lt;var&gt; tag with optional contents
    /// </summary>
    /// <returns>
    /// A Var object with all the attributes available in that tag
    /// </returns>
    /// <param name="content">one or more objects (strings or tags) which will be inside the tag</param>
    /// <code>
    /// var var = Tag.Var();
    /// var var2 = Tag.Var("hello there");
    /// </code>
    public static Var Var(params object[] content) => new Var(content) { IsImmutable = false };

    /// <summary>
    /// Generate a standard HTML5 &lt;video&gt; tag with optional contents
    /// </summary>
    /// <returns>
    /// A Video object with all the attributes available in that tag
    /// </returns>
    /// <param name="content">one or more objects (strings or tags) which will be inside the tag</param>
    /// <code>
    /// var video = Tag.Video();
    /// var video2 = Tag.Video("hello there");
    /// </code>
    public static Video Video(params object[] content) => new Video(content) { IsImmutable = false };

    /// <summary>
    /// Generate a standard HTML5 &lt;wbr&gt; tag with optional contents
    /// </summary>
    /// <returns>
    /// A Wbr object with all the attributes available in that tag
    /// </returns>
    /// <param name="content">one or more objects (strings or tags) which will be inside the tag</param>
    /// <code>
    /// var wbr = Tag.Wbr();
    /// </code>
    public static Wbr Wbr(params object[] content) => new Wbr(content) { IsImmutable = false };
    }
}