Code Duplication - royallthefourth/html-document - Measure and Improve Code Quality continuously with Scrutinizer


 * Class Abbreviation
 * @see https://developer.mozilla.org/en-US/docs/Web/HTML/Element/abbr
 */
final class Abbreviation extends AbstractElement implements ParentElementInterface
{
    public function __construct(AttributeSet $attributes = null, ElementSet $children = null)
    {
        $this->attributes = $attributes ?? new AttributeSet();
        $this->children = $children ?? new ElementSet();

        $this->tag = new Standard('abbr', $attributes, $children);
    }

    public function withAttribute(string $name, string $value = null): Abbreviation
    {
        if ($value) {
            $attribute = new StandardAttribute($name, $value);
        } else {
            $attribute = new BooleanAttribute($name);
        }

        return new Abbreviation($this->attributes->add($attribute), $this->children);
    }

    public function withChild(ElementInterface $element): Abbreviation
    {
        return new Abbreviation($this->attributes, $this->children->add($element));
    }

    public function withTitle(string $title): Abbreviation
    {
        return $this->withAttribute('title', $title);
    }
}



 * Class Address
 * @see https://developer.mozilla.org/en-US/docs/Web/HTML/Element/address
 */
final class Address extends AbstractElement
{
    public function __construct(AttributeSet $attributes = null, ElementSet $children = null)
    {
        $this->attributes = $attributes ?? new AttributeSet();
        $this->children = $children ?? new ElementSet();

        $this->tag = new Standard('address', $attributes, $children);
    }

    public function withAttribute(string $name, string $value = null): Address
    {
        if ($value) {
            $attribute = new StandardAttribute($name, $value);
        } else {
            $attribute = new BooleanAttribute($name);
        }

        return new Address($this->attributes->add($attribute), $this->children);
    }

    public function withChild(ElementInterface $element): Address
    {
        return new Address($this->attributes, $this->children->add($element));
    }
}



 * Class Article
 * @see https://developer.mozilla.org/en-US/docs/Web/HTML/Element/article
 */
final class Article extends AbstractElement implements ParentElementInterface
{
    public function __construct(AttributeSet $attributes = null, ElementSet $children = null)
    {
        $this->attributes = $attributes ?? new AttributeSet();
        $this->children = $children ?? new ElementSet();
        $this->tag = new Standard('article', $attributes, $children);
    }

    public function withAttribute(string $name, string $value = null): Article
    {
        if ($value) {
            $attribute = new StandardAttribute($name, $value);
        } else {
            $attribute = new BooleanAttribute($name);
        }

        return new Article($this->attributes->add($attribute), $this->children);
    }

    public function withChild(ElementInterface $element): Article
    {
        return new Article($this->attributes, $this->children->add($element));
    }
}



 * Class Aside
 * @see https://developer.mozilla.org/en-US/docs/Web/HTML/Element/aside
 */
final class Aside extends AbstractElement implements ParentElementInterface
{
    public function __construct(AttributeSet $attributes = null, ElementSet $children = null)
    {
        $this->attributes = $attributes ?? new AttributeSet();
        $this->children = $children ?? new ElementSet();
        $this->tag = new Standard('aside', $attributes, $children);
    }

    public function withAttribute(string $name, string $value = null): Aside
    {
        if ($value) {
            $attribute = new StandardAttribute($name, $value);
        } else {
            $attribute = new BooleanAttribute($name);
        }

        return new Aside($this->attributes->add($attribute), $this->children);
    }

    public function withChild(ElementInterface $element): Aside
    {
        return new Aside($this->attributes, $this->children->add($element));
    }
}



 * Class B
 * @see https://developer.mozilla.org/en-US/docs/Web/HTML/Element/b
 */
final class B extends AbstractElement implements ParentElementInterface
{
    public function __construct(AttributeSet $attributes = null, ElementSet $children = null)
    {
        $this->attributes = $attributes ?? new AttributeSet();
        $this->children = $children ?? new ElementSet();
        $this->tag = new Standard('b', $attributes, $children);
    }

    public function withAttribute(string $name, string $value = null): B
    {
        if ($value) {
            $attribute = new StandardAttribute($name, $value);
        } else {
            $attribute = new BooleanAttribute($name);
        }

        return new B($this->attributes->add($attribute), $this->children);
    }

    public function withChild(ElementInterface $element): B
    {
        return new B($this->attributes, $this->children->add($element));
    }
}



 * Class BiDirectionalIsolation
 * @see https://developer.mozilla.org/en-US/docs/Web/HTML/Element/bdi
 */
final class BiDirectionalIsolation extends AbstractElement implements ParentElementInterface
{
    public function __construct(AttributeSet $attributes = null, ElementSet $children = null)
    {
        $this->attributes = $attributes ?? new AttributeSet();
        $this->children = $children ?? new ElementSet();
        $this->tag = new Standard('bdi', $attributes, $children);
    }

    public function withAttribute(string $name, string $value = null): BiDirectionalIsolation
    {
        if ($value) {
            $attribute = new StandardAttribute($name, $value);
        } else {
            $attribute = new BooleanAttribute($name);
        }

        return new BiDirectionalIsolation($this->attributes->add($attribute), $this->children);
    }

    public function withChild(ElementInterface $element): BiDirectionalIsolation
    {
        return new BiDirectionalIsolation($this->attributes, $this->children->add($element));
    }
}



 * Class BiDirectionalOverride
 * @see https://developer.mozilla.org/en-US/docs/Web/HTML/Element/bdo
 */
final class BiDirectionalOverride extends AbstractElement implements ParentElementInterface
{
    public function __construct(AttributeSet $attributes = null, ElementSet $children = null)
    {
        $this->attributes = $attributes ?? new AttributeSet();
        $this->children = $children ?? new ElementSet();
        $this->tag = new Standard('bdo', $attributes, $children);
    }

    public function withAttribute(string $name, string $value = null): BiDirectionalOverride
    {
        if ($value) {
            $attribute = new StandardAttribute($name, $value);
        } else {
            $attribute = new BooleanAttribute($name);
        }

        return new BiDirectionalOverride($this->attributes->add($attribute), $this->children);
    }

    public function withChild(ElementInterface $element): BiDirectionalOverride
    {
        return new BiDirectionalOverride($this->attributes, $this->children->add($element));
    }

    public function withDir(string $direction = 'auto'): BiDirectionalOverride
    {
        return $this->withAttribute('dir', $direction);
    }
}



 * Class BlockQuote
 * @see https://developer.mozilla.org/en-US/docs/Web/HTML/Element/blockquote
 */
final class BlockQuote extends AbstractElement implements ParentElementInterface
{
    public function __construct(AttributeSet $attributes = null, ElementSet $children = null)
    {
        $this->attributes = $attributes ?? new AttributeSet();
        $this->children = $children ?? new ElementSet();
        $this->tag = new Standard('blockquote', $attributes, $children);
    }

    public function withAttribute(string $name, string $value = null): BlockQuote
    {
        if ($value) {
            $attribute = new StandardAttribute($name, $value);
        } else {
            $attribute = new BooleanAttribute($name);
        }

        return new BlockQuote($this->attributes->add($attribute), $this->children);
    }

    public function withChild(ElementInterface $element): BlockQuote
    {
        return new BlockQuote($this->attributes, $this->children->add($element));
    }

    public function withCite(string $url): BlockQuote
    {
        return $this->withAttribute('cite', $url);
    }
}



 * Class Body
 * @see https://developer.mozilla.org/en-US/docs/Web/HTML/Element/body
 */
final class Body extends AbstractElement implements ParentElementInterface
{
    public function __construct(AttributeSet $attributes = null, ElementSet $children = null)
    {
        $this->attributes = $attributes ?? new AttributeSet();
        $this->children = $children ?? new ElementSet();
        $this->tag = new Standard('body', $attributes, $children);
    }

    public function withAttribute(string $name, string $value = null): Body
    {
        if ($value) {
            $attribute = new StandardAttribute($name, $value);
        } else {
            $attribute = new BooleanAttribute($name);
        }

        return new Body($this->attributes->add($attribute), $this->children);
    }

    public function withChild(ElementInterface $element): Body
    {
        return new Body($this->attributes, $this->children->add($element));
    }
}



 * Class Caption
 * @see https://developer.mozilla.org/en-US/docs/Web/HTML/Element/caption
 */
final class Caption extends AbstractElement implements ParentElementInterface
{
    public function __construct(AttributeSet $attributes = null, ElementSet $children = null)
    {
        $this->attributes = $attributes ?? new AttributeSet();
        $this->children = $children ?? new ElementSet();
        $this->tag = new Standard('caption', $attributes, $children);
    }

    public function withAttribute(string $name, string $value = null): Caption
    {
        if ($value) {
            $attribute = new StandardAttribute($name, $value);
        } else {
            $attribute = new BooleanAttribute($name);
        }

        return new Caption($this->attributes->add($attribute), $this->children);
    }

    public function withChild(ElementInterface $element): Caption
    {
        return new Caption($this->attributes, $this->children->add($element));
    }
}



 * Class Cite
 * @see https://developer.mozilla.org/en-US/docs/Web/HTML/Element/cite
 */
final class Cite extends AbstractElement implements ParentElementInterface
{
    public function __construct(AttributeSet $attributes = null, ElementSet $children = null)
    {
        $this->attributes = $attributes ?? new AttributeSet();
        $this->children = $children ?? new ElementSet();
        $this->tag = new Standard('cite', $attributes, $children);
    }

    public function withAttribute(string $name, string $value = null): Cite
    {
        if ($value) {
            $attribute = new StandardAttribute($name, $value);
        } else {
            $attribute = new BooleanAttribute($name);
        }

        return new Cite($this->attributes->add($attribute), $this->children);
    }

    public function withChild(ElementInterface $element): Cite
    {
        return new Cite($this->attributes, $this->children->add($element));
    }
}



 * Class Code
 * @see https://developer.mozilla.org/en-US/docs/Web/HTML/Element/code
 */
final class Code extends AbstractElement implements ParentElementInterface
{
    public function __construct(AttributeSet $attributes = null, ElementSet $children = null)
    {
        $this->attributes = $attributes ?? new AttributeSet();
        $this->children = $children ?? new ElementSet();
        $this->tag = new Standard('code', $attributes, $children);
    }

    public function withAttribute(string $name, string $value = null): Code
    {
        if ($value) {
            $attribute = new StandardAttribute($name, $value);
        } else {
            $attribute = new BooleanAttribute($name);
        }

        return new Code($this->attributes->add($attribute), $this->children);
    }

    public function withChild(ElementInterface $element): Code
    {
        return new Code($this->attributes, $this->children->add($element));
    }
}



 * Class ColumnGroup
 * @see https://developer.mozilla.org/en-US/docs/Web/HTML/Element/colgroup
 */
final class ColumnGroup extends AbstractElement implements ParentElementInterface
{
    public function __construct(AttributeSet $attributes = null, ElementSet $children = null)
    {
        $this->attributes = $attributes ?? new AttributeSet();
        $this->children = $children ?? new ElementSet();
        $this->tag = new Standard('colgroup', $attributes, $children);
    }

    public function withAttribute(string $name, string $value = null): ColumnGroup
    {
        if ($value) {
            $attribute = new StandardAttribute($name, $value);
        } else {
            $attribute = new BooleanAttribute($name);
        }

        return new ColumnGroup($this->attributes->add($attribute), $this->children);
    }

    public function withChild(ElementInterface $element): ColumnGroup
    {
        return new ColumnGroup($this->attributes, $this->children->add($element));
    }

    public function withSpan(int $span = 1): ColumnGroup
    {
        return $this->withAttribute('span', $span);
    }
}



 * Class Data
 * @see https://developer.mozilla.org/en-US/docs/Web/HTML/Element/data
 */
final class Data extends AbstractElement implements ParentElementInterface
{
    public function __construct(AttributeSet $attributes = null, ElementSet $children = null)
    {
        $this->attributes = $attributes ?? new AttributeSet();
        $this->children = $children ?? new ElementSet();
        $this->tag = new Standard('data', $attributes, $children);
    }

    public function withAttribute(string $name, string $value = null): Data
    {
        if ($value) {
            $attribute = new StandardAttribute($name, $value);
        } else {
            $attribute = new BooleanAttribute($name);
        }

        return new Data($this->attributes->add($attribute), $this->children);
    }

    public function withChild(ElementInterface $element): Data
    {
        return new Data($this->attributes, $this->children->add($element));
    }

    public function withValue(string $value): Data
    {
        return $this->withAttribute('value', $value);
    }
}



 * Class DataList
 * @see https://developer.mozilla.org/en-US/docs/Web/HTML/Element/datalist
 */
final class DataList extends AbstractElement implements ParentElementInterface
{
    public function __construct(AttributeSet $attributes = null, ElementSet $children = null)
    {
        $this->attributes = $attributes ?? new AttributeSet();
        $this->children = $children ?? new ElementSet();
        $this->tag = new Standard('datalist', $attributes, $children);
    }

    public function withAttribute(string $name, string $value = null): DataList
    {
        if ($value) {
            $attribute = new StandardAttribute($name, $value);
        } else {
            $attribute = new BooleanAttribute($name);
        }

        return new DataList($this->attributes->add($attribute), $this->children);
    }

    public function withChild(ElementInterface $element): DataList
    {
        return new DataList($this->attributes, $this->children->add($element));
    }
}



 * Class Definition
 * @see https://developer.mozilla.org/en-US/docs/Web/HTML/Element/dfn
 */
final class Definition extends AbstractElement implements ParentElementInterface
{
    public function __construct(AttributeSet $attributes = null, ElementSet $children = null)
    {
        $this->attributes = $attributes ?? new AttributeSet();
        $this->children = $children ?? new ElementSet();
        $this->tag = new Standard('dfn', $attributes, $children);
    }

    public function withAttribute(string $name, string $value = null): Definition
    {
        if ($value) {
            $attribute = new StandardAttribute($name, $value);
        } else {
            $attribute = new BooleanAttribute($name);
        }

        return new Definition($this->attributes->add($attribute), $this->children);
    }

    public function withChild(ElementInterface $element): Definition
    {
        return new Definition($this->attributes, $this->children->add($element));
    }
}



 * Class Description
 * @see https://developer.mozilla.org/en-US/docs/Web/HTML/Element/dd
 */
final class Description extends AbstractElement implements ParentElementInterface
{
    public function __construct(AttributeSet $attributes = null, ElementSet $children = null)
    {
        $this->attributes = $attributes ?? new AttributeSet();
        $this->children = $children ?? new ElementSet();
        $this->tag = new Standard('dd', $attributes, $children);
    }

    public function withAttribute(string $name, string $value = null): Description
    {
        if ($value) {
            $attribute = new StandardAttribute($name, $value);
        } else {
            $attribute = new BooleanAttribute($name);
        }

        return new Description($this->attributes->add($attribute), $this->children);
    }

    public function withChild(ElementInterface $element): Description
    {
        return new Description($this->attributes, $this->children->add($element));
    }
}



 * Class DescriptionList
 * @see https://developer.mozilla.org/en-US/docs/Web/HTML/Element/dl
 */
final class DescriptionList extends AbstractElement implements ParentElementInterface
{
    public function __construct(AttributeSet $attributes = null, ElementSet $children = null)
    {
        $this->attributes = $attributes ?? new AttributeSet();
        $this->children = $children ?? new ElementSet();
        $this->tag = new Standard('dl', $attributes, $children);
    }

    public function withAttribute(string $name, string $value = null): DescriptionList
    {
        if ($value) {
            $attribute = new StandardAttribute($name, $value);
        } else {
            $attribute = new BooleanAttribute($name);
        }

        return new DescriptionList($this->attributes->add($attribute), $this->children);
    }

    public function withChild(ElementInterface $element): DescriptionList
    {
        return new DescriptionList($this->attributes, $this->children->add($element));
    }
}



 * Class DescriptionTerm
 * @see https://developer.mozilla.org/en-US/docs/Web/HTML/Element/dt
 */
final class DescriptionTerm extends AbstractElement implements ParentElementInterface
{
    public function __construct(AttributeSet $attributes = null, ElementSet $children = null)
    {
        $this->attributes = $attributes ?? new AttributeSet();
        $this->children = $children ?? new ElementSet();
        $this->tag = new Standard('dt', $attributes, $children);
    }

    public function withAttribute(string $name, string $value = null): DescriptionTerm
    {
        if ($value) {
            $attribute = new StandardAttribute($name, $value);
        } else {
            $attribute = new BooleanAttribute($name);
        }

        return new DescriptionTerm($this->attributes->add($attribute), $this->children);
    }

    public function withChild(ElementInterface $element): DescriptionTerm
    {
        return new DescriptionTerm($this->attributes, $this->children->add($element));
    }
}



 * Class Details
 * @see https://developer.mozilla.org/en-US/docs/Web/HTML/Element/details
 */
final class Details extends AbstractElement implements ParentElementInterface
{
    public function __construct(AttributeSet $attributes = null, ElementSet $children = null)
    {
        $this->attributes = $attributes ?? new AttributeSet();
        $this->children = $children ?? new ElementSet();
        $this->tag = new Standard('details', $attributes, $children);
    }

    public function withAttribute(string $name, string $value = null): Details
    {
        if ($value) {
            $attribute = new StandardAttribute($name, $value);
        } else {
            $attribute = new BooleanAttribute($name);
        }

        return new Details($this->attributes->add($attribute), $this->children);
    }

    public function withChild(ElementInterface $element): Details
    {
        return new Details($this->attributes, $this->children->add($element));
    }

    public function withOpen(string $open = 'false'): Details
    {
        return $this->withAttribute('open', $open);
    }
}



 * Class Division
 * @see https://developer.mozilla.org/en-US/docs/Web/HTML/Element/div
 */
final class Division extends AbstractElement implements ParentElementInterface
{
    public function __construct(AttributeSet $attributes = null, ElementSet $children = null)
    {
        $this->attributes = $attributes ?? new AttributeSet();
        $this->children = $children ?? new ElementSet();
        $this->tag = new Standard('div', $attributes, $children);
    }

    public function withAttribute(string $name, string $value = null): Division
    {
        if ($value) {
            $attribute = new StandardAttribute($name, $value);
        } else {
            $attribute = new BooleanAttribute($name);
        }

        return new Division($this->attributes->add($attribute), $this->children);
    }

    public function withChild(ElementInterface $element): Division
    {
        return new Division($this->attributes, $this->children->add($element));
    }
}



 * Class Emphasis
 * @see https://developer.mozilla.org/en-US/docs/Web/HTML/Element/em
 */
final class Emphasis extends AbstractElement
{
    public function __construct(AttributeSet $attributes = null, ElementSet $children = null)
    {
        $this->attributes = $attributes ?? new AttributeSet();
        $this->children = $children ?? new ElementSet();
        $this->tag = new Standard('em', $attributes, $children);
    }

    public function withAttribute(string $name, string $value = null): Emphasis
    {
        if ($value) {
            $attribute = new StandardAttribute($name, $value);
        } else {
            $attribute = new BooleanAttribute($name);
        }

        return new Emphasis($this->attributes->add($attribute), $this->children);
    }

    public function withChild(ElementInterface $element): Emphasis
    {
        return new Emphasis($this->attributes, $this->children->add($element));
    }
}



 * Class Figure
 * @see https://developer.mozilla.org/en-US/docs/Web/HTML/Element/figure
 */
final class Figure extends AbstractElement implements ParentElementInterface
{
    public function __construct(AttributeSet $attributes = null, ElementSet $children = null)
    {
        $this->attributes = $attributes ?? new AttributeSet();
        $this->children = $children ?? new ElementSet();
        $this->tag = new Standard('figure', $attributes, $children);
    }

    public function withAttribute(string $name, string $value = null): Figure
    {
        if ($value) {
            $attribute = new StandardAttribute($name, $value);
        } else {
            $attribute = new BooleanAttribute($name);
        }

        return new Figure($this->attributes->add($attribute), $this->children);
    }

    public function withChild(ElementInterface $element): Figure
    {
        return new Figure($this->attributes, $this->children->add($element));
    }
}



 * Class FigureCaption
 * @see https://developer.mozilla.org/en-US/docs/Web/HTML/Element/figcaption
 */
final class FigureCaption extends AbstractElement implements ParentElementInterface
{
    public function __construct(AttributeSet $attributes = null, ElementSet $children = null)
    {
        $this->attributes = $attributes ?? new AttributeSet();
        $this->children = $children ?? new ElementSet();
        $this->tag = new Standard('figcaption', $attributes, $children);
    }

    public function withAttribute(string $name, string $value = null): FigureCaption
    {
        if ($value) {
            $attribute = new StandardAttribute($name, $value);
        } else {
            $attribute = new BooleanAttribute($name);
        }

        return new FigureCaption($this->attributes->add($attribute), $this->children);
    }

    public function withChild(ElementInterface $element): FigureCaption
    {
        return new FigureCaption($this->attributes, $this->children->add($element));
    }
}



 * Class Footer
 * @see https://developer.mozilla.org/en-US/docs/Web/HTML/Element/footer
 */
final class Footer extends AbstractElement implements ParentElementInterface
{
    public function __construct(AttributeSet $attributes = null, ElementSet $children = null)
    {
        $this->attributes = $attributes ?? new AttributeSet();
        $this->children = $children ?? new ElementSet();
        $this->tag = new Standard('footer', $attributes, $children);
    }

    public function withAttribute(string $name, string $value = null): Footer
    {
        if ($value) {
            $attribute = new StandardAttribute($name, $value);
        } else {
            $attribute = new BooleanAttribute($name);
        }

        return new Footer($this->attributes->add($attribute), $this->children);
    }

    public function withChild(ElementInterface $element): Footer
    {
        return new Footer($this->attributes, $this->children->add($element));
    }
}



 * Class Head
 * @see https://developer.mozilla.org/en-US/docs/Web/HTML/Element/head
 */
final class Head extends AbstractElement implements ParentElementInterface
{
    public function __construct(AttributeSet $attributes = null, ElementSet $children = null)
    {
        $this->attributes = $attributes ?? new AttributeSet();
        $this->children = $children ?? new ElementSet();
        $this->tag = new Standard('head', $attributes, $children);
    }

    public function withAttribute(string $name, string $value = null): Head
    {
        if ($value) {
            $attribute = new StandardAttribute($name, $value);
        } else {
            $attribute = new BooleanAttribute($name);
        }

        return new Head($this->attributes->add($attribute), $this->children);
    }

    public function withChild(ElementInterface $element): Head
    {
        return new Head($this->attributes, $this->children->add($element));
    }
}



 * Class Header
 * @see https://developer.mozilla.org/en-US/docs/Web/HTML/Element/header
 */
final class Header extends AbstractElement implements ParentElementInterface
{
    public function __construct(AttributeSet $attributes = null, ElementSet $children = null)
    {
        $this->attributes = $attributes ?? new AttributeSet();
        $this->children = $children ?? new ElementSet();
        $this->tag = new Standard('header', $attributes, $children);
    }

    public function withAttribute(string $name, string $value = null): Header
    {
        if ($value) {
            $attribute = new StandardAttribute($name, $value);
        } else {
            $attribute = new BooleanAttribute($name);
        }

        return new Header($this->attributes->add($attribute), $this->children);
    }

    public function withChild(ElementInterface $element): Header
    {
        return new Header($this->attributes, $this->children->add($element));
    }
}



 * Class Html
 * @see https://developer.mozilla.org/en-US/docs/Web/HTML/Element/html
 */
final class Html extends AbstractElement implements ParentElementInterface
{
    public function __construct(AttributeSet $attributes = null, ElementSet $children = null)
    {
        $this->attributes = $attributes ?? new AttributeSet();
        $this->children = $children ?? new ElementSet();
        $this->tag = new Standard('html', $attributes, $children);
    }

    public function withAttribute(string $name, string $value = null): Html
    {
        if ($value) {
            $attribute = new StandardAttribute($name, $value);
        } else {
            $attribute = new BooleanAttribute($name);
        }

        return new Html($this->attributes->add($attribute), $this->children);
    }

    public function withChild(ElementInterface $element): Html
    {
        return new Html($this->attributes, $this->children->add($element));
    }
}



 * Class I
 * @see https://developer.mozilla.org/en-US/docs/Web/HTML/Element/i
 */
final class I extends AbstractElement implements ParentElementInterface
{
    public function __construct(AttributeSet $attributes = null, ElementSet $children = null)
    {
        $this->attributes = $attributes ?? new AttributeSet();
        $this->children = $children ?? new ElementSet();
        $this->tag = new Standard('i', $attributes, $children);
    }

    public function withAttribute(string $name, string $value = null): I
    {
        if ($value) {
            $attribute = new StandardAttribute($name, $value);
        } else {
            $attribute = new BooleanAttribute($name);
        }

        return new I($this->attributes->add($attribute), $this->children);
    }

    public function withChild(ElementInterface $element): I
    {
        return new I($this->attributes, $this->children->add($element));
    }
}



 * Class Keyboard
 * @see https://developer.mozilla.org/en-US/docs/Web/HTML/Element/kbd
 */
final class Keyboard extends AbstractElement implements ParentElementInterface
{
    public function __construct(AttributeSet $attributes = null, ElementSet $children = null)
    {
        $this->attributes = $attributes ?? new AttributeSet();
        $this->children = $children ?? new ElementSet();
        $this->tag = new Standard('kbd', $attributes, $children);
    }

    public function withAttribute(string $name, string $value = null): Keyboard
    {
        if ($value) {
            $attribute = new StandardAttribute($name, $value);
        } else {
            $attribute = new BooleanAttribute($name);
        }

        return new Keyboard($this->attributes->add($attribute), $this->children);
    }

    public function withChild(ElementInterface $element): Keyboard
    {
        return new Keyboard($this->attributes, $this->children->add($element));
    }
}



 * Class Label
 * @see https://developer.mozilla.org/en-US/docs/Web/HTML/Element/label
 */
final class Label extends AbstractElement implements ParentElementInterface
{
    public function __construct(AttributeSet $attributes = null, ElementSet $children = null)
    {
        $this->attributes = $attributes ?? new AttributeSet();
        $this->children = $children ?? new ElementSet();
        $this->tag = new Standard('label', $attributes, $children);
    }

    public function withAttribute(string $name, string $value = null): Label
    {
        if ($value) {
            $attribute = new StandardAttribute($name, $value);
        } else {
            $attribute = new BooleanAttribute($name);
        }

        return new Label($this->attributes->add($attribute), $this->children);
    }

    public function withChild(ElementInterface $element): Label
    {
        return new Label($this->attributes, $this->children->add($element));
    }

    public function withFor(string $id): Label
    {
        return $this->withAttribute('for', $id);
    }
}



 * Class Legend
 * @see https://developer.mozilla.org/en-US/docs/Web/HTML/Element/legend
 */
final class Legend extends AbstractElement implements ParentElementInterface
{
    public function __construct(AttributeSet $attributes = null, ElementSet $children = null)
    {
        $this->attributes = $attributes ?? new AttributeSet();
        $this->children = $children ?? new ElementSet();
        $this->tag = new Standard('legend', $attributes, $children);
    }

    public function withAttribute(string $name, string $value = null): Legend
    {
        if ($value) {
            $attribute = new StandardAttribute($name, $value);
        } else {
            $attribute = new BooleanAttribute($name);
        }

        return new Legend($this->attributes->add($attribute), $this->children);
    }

    public function withChild(ElementInterface $element): Legend
    {
        return new Legend($this->attributes, $this->children->add($element));
    }
}



 * Class ListItem
 * @see https://developer.mozilla.org/en-US/docs/Web/HTML/Element/li
 */
final class ListItem extends AbstractElement implements ParentElementInterface
{
    public function __construct(AttributeSet $attributes = null, ElementSet $children = null)
    {
        $this->attributes = $attributes ?? new AttributeSet();
        $this->children = $children ?? new ElementSet();
        $this->tag = new Standard('li', $attributes, $children);
    }

    public function withAttribute(string $name, string $value = null): ListItem
    {
        if ($value) {
            $attribute = new StandardAttribute($name, $value);
        } else {
            $attribute = new BooleanAttribute($name);
        }

        return new ListItem($this->attributes->add($attribute), $this->children);
    }

    public function withChild(ElementInterface $element): ListItem
    {
        return new ListItem($this->attributes, $this->children->add($element));
    }

    public function withValue(int $value): ListItem
    {
        return $this->withAttribute('value', $value);
    }
}



 * Class Main
 * @see https://developer.mozilla.org/en-US/docs/Web/HTML/Element/main
 */
final class Main extends AbstractElement implements ParentElementInterface
{
    public function __construct(AttributeSet $attributes = null, ElementSet $children = null)
    {
        $this->attributes = $attributes ?? new AttributeSet();
        $this->children = $children ?? new ElementSet();
        $this->tag = new Standard('main', $attributes, $children);
    }

    public function withAttribute(string $name, string $value = null): Main
    {
        if ($value) {
            $attribute = new StandardAttribute($name, $value);
        } else {
            $attribute = new BooleanAttribute($name);
        }

        return new Main($this->attributes->add($attribute), $this->children);
    }

    public function withChild(ElementInterface $element): Main
    {
        return new Main($this->attributes, $this->children->add($element));
    }
}



 * Class Map
 * @see https://developer.mozilla.org/en-US/docs/Web/HTML/Element/map
 */
final class Map extends AbstractElement implements ParentElementInterface
{
    public function __construct(AttributeSet $attributes = null, ElementSet $children = null)
    {
        $this->attributes = $attributes ?? new AttributeSet();
        $this->children = $children ?? new ElementSet();
        $this->tag = new Standard('map', $attributes, $children);
    }

    public function withAttribute(string $name, string $value = null): Map
    {
        if ($value) {
            $attribute = new StandardAttribute($name, $value);
        } else {
            $attribute = new BooleanAttribute($name);
        }

        return new Map($this->attributes->add($attribute), $this->children);
    }

    public function withChild(ElementInterface $element): Map
    {
        return new Map($this->attributes, $this->children->add($element));
    }

    public function withName(string $name): Map
    {
        return $this->withAttribute('name', $name);
    }
}



 * Class Mark
 * @see https://developer.mozilla.org/en-US/docs/Web/HTML/Element/mark
 */
final class Mark extends AbstractElement implements ParentElementInterface
{
    public function __construct(AttributeSet $attributes = null, ElementSet $children = null)
    {
        $this->attributes = $attributes ?? new AttributeSet();
        $this->children = $children ?? new ElementSet();
        $this->tag = new Standard('mark', $attributes, $children);
    }

    public function withAttribute(string $name, string $value = null): Mark
    {
        if ($value) {
            $attribute = new StandardAttribute($name, $value);
        } else {
            $attribute = new BooleanAttribute($name);
        }

        return new Mark($this->attributes->add($attribute), $this->children);
    }

    public function withChild(ElementInterface $element): Mark
    {
        return new Mark($this->attributes, $this->children->add($element));
    }
}



 * Class Nav
 * @see https://developer.mozilla.org/en-US/docs/Web/HTML/Element/nav
 */
final class Nav extends AbstractElement implements ParentElementInterface
{
    public function __construct(AttributeSet $attributes = null, ElementSet $children = null)
    {
        $this->attributes = $attributes ?? new AttributeSet();
        $this->children = $children ?? new ElementSet();
        $this->tag = new Standard('nav', $attributes, $children);
    }

    public function withAttribute(string $name, string $value = null): Nav
    {
        if ($value) {
            $attribute = new StandardAttribute($name, $value);
        } else {
            $attribute = new BooleanAttribute($name);
        }

        return new Nav($this->attributes->add($attribute), $this->children);
    }

    public function withChild(ElementInterface $element): Nav
    {
        return new Nav($this->attributes, $this->children->add($element));
    }
}



 * Class NoScript
 * @see https://developer.mozilla.org/en-US/docs/Web/HTML/Element/noscript
 */
final class NoScript extends AbstractElement implements ParentElementInterface
{
    public function __construct(AttributeSet $attributes = null, ElementSet $children = null)
    {
        $this->attributes = $attributes ?? new AttributeSet();
        $this->children = $children ?? new ElementSet();
        $this->tag = new Standard('noscript', $attributes, $children);
    }

    public function withAttribute(string $name, string $value = null): NoScript
    {
        if ($value) {
            $attribute = new StandardAttribute($name, $value);
        } else {
            $attribute = new BooleanAttribute($name);
        }

        return new NoScript($this->attributes->add($attribute), $this->children);
    }

    public function withChild(ElementInterface $element): NoScript
    {
        return new NoScript($this->attributes, $this->children->add($element));
    }
}



 * Class Paragraph
 * @see https://developer.mozilla.org/en-US/docs/Web/HTML/Element/p
 */
final class Paragraph extends AbstractElement implements ParentElementInterface
{
    public function __construct(AttributeSet $attributes = null, ElementSet $children = null)
    {
        $this->attributes = $attributes ?? new AttributeSet();
        $this->children = $children ?? new ElementSet();
        $this->tag = new Standard('p', $attributes, $children);
    }

    public function withAttribute(string $name, string $value = null): Paragraph
    {
        if ($value) {
            $attribute = new StandardAttribute($name, $value);
        } else {
            $attribute = new BooleanAttribute($name);
        }

        return new Paragraph($this->attributes->add($attribute), $this->children);
    }

    public function withChild(ElementInterface $element): Paragraph
    {
        return new Paragraph($this->attributes, $this->children->add($element));
    }
}



 * Class Pre
 * @see https://developer.mozilla.org/en-US/docs/Web/HTML/Element/pre
 */
final class Pre extends AbstractElement implements ParentElementInterface
{
    public function __construct(AttributeSet $attributes = null, ElementSet $children = null)
    {
        $this->attributes = $attributes ?? new AttributeSet();
        $this->children = $children ?? new ElementSet();
        $this->tag = new Standard('pre', $attributes, $children);
    }

    public function withAttribute(string $name, string $value = null): Pre
    {
        if ($value) {
            $attribute = new StandardAttribute($name, $value);
        } else {
            $attribute = new BooleanAttribute($name);
        }

        return new Pre($this->attributes->add($attribute), $this->children);
    }

    public function withChild(ElementInterface $element): Pre
    {
        return new Pre($this->attributes, $this->children->add($element));
    }
}



 * Class Quote
 * @see https://developer.mozilla.org/en-US/docs/Web/HTML/Element/q
 */
final class Quote extends AbstractElement implements ParentElementInterface
{
    public function __construct(AttributeSet $attributes = null, ElementSet $children = null)
    {
        $this->attributes = $attributes ?? new AttributeSet();
        $this->children = $children ?? new ElementSet();
        $this->tag = new Standard('q', $attributes, $children);
    }

    public function withAttribute(string $name, string $value = null): Quote
    {
        if ($value) {
            $attribute = new StandardAttribute($name, $value);
        } else {
            $attribute = new BooleanAttribute($name);
        }

        return new Quote($this->attributes->add($attribute), $this->children);
    }

    public function withChild(ElementInterface $element): Quote
    {
        return new Quote($this->attributes, $this->children->add($element));
    }

    public function withCite(string $url): Quote
    {
        return $this->withAttribute('cite', $url);
    }
}



 * Class Rp
 * @see https://developer.mozilla.org/en-US/docs/Web/HTML/Element/rp
 */
final class Rp extends AbstractElement implements ParentElementInterface
{
    public function __construct(AttributeSet $attributes = null, ElementSet $children = null)
    {
        $this->attributes = $attributes ?? new AttributeSet();
        $this->children = $children ?? new ElementSet();
        $this->tag = new Standard('rp', $attributes, $children);
    }

    public function withAttribute(string $name, string $value = null): Rp
    {
        if ($value) {
            $attribute = new StandardAttribute($name, $value);
        } else {
            $attribute = new BooleanAttribute($name);
        }

        return new Rp($this->attributes->add($attribute), $this->children);
    }

    public function withChild(ElementInterface $element): Rp
    {
        return new Rp($this->attributes, $this->children->add($element));
    }
}



 * Class Rt
 * @see https://developer.mozilla.org/en-US/docs/Web/HTML/Element/rt
 */
final class Rt extends AbstractElement implements ParentElementInterface
{
    public function __construct(AttributeSet $attributes = null, ElementSet $children = null)
    {
        $this->attributes = $attributes ?? new AttributeSet();
        $this->children = $children ?? new ElementSet();
        $this->tag = new Standard('rt', $attributes, $children);
    }

    public function withAttribute(string $name, string $value = null): Rt
    {
        if ($value) {
            $attribute = new StandardAttribute($name, $value);
        } else {
            $attribute = new BooleanAttribute($name);
        }

        return new Rt($this->attributes->add($attribute), $this->children);
    }

    public function withChild(ElementInterface $element): Rt
    {
        return new Rt($this->attributes, $this->children->add($element));
    }
}



 * Class Ruby
 * @see https://developer.mozilla.org/en-US/docs/Web/HTML/Element/ruby
 */
final class Ruby extends AbstractElement implements ParentElementInterface
{
    public function __construct(AttributeSet $attributes = null, ElementSet $children = null)
    {
        $this->attributes = $attributes ?? new AttributeSet();
        $this->children = $children ?? new ElementSet();
        $this->tag = new Standard('ruby', $attributes, $children);
    }

    public function withAttribute(string $name, string $value = null): Ruby
    {
        if ($value) {
            $attribute = new StandardAttribute($name, $value);
        } else {
            $attribute = new BooleanAttribute($name);
        }

        return new Ruby($this->attributes->add($attribute), $this->children);
    }

    public function withChild(ElementInterface $element): Ruby
    {
        return new Ruby($this->attributes, $this->children->add($element));
    }
}



 * Class Sample
 * @see https://developer.mozilla.org/en-US/docs/Web/HTML/Element/samp
 */
final class Sample extends AbstractElement implements ParentElementInterface
{
    public function __construct(AttributeSet $attributes = null, ElementSet $children = null)
    {
        $this->attributes = $attributes ?? new AttributeSet();
        $this->children = $children ?? new ElementSet();
        $this->tag = new Standard('samp', $attributes, $children);
    }

    public function withAttribute(string $name, string $value = null): Sample
    {
        if ($value) {
            $attribute = new StandardAttribute($name, $value);
        } else {
            $attribute = new BooleanAttribute($name);
        }

        return new Sample($this->attributes->add($attribute), $this->children);
    }

    public function withChild(ElementInterface $element): Sample
    {
        return new Sample($this->attributes, $this->children->add($element));
    }
}



 * Class Section
 * @see https://developer.mozilla.org/en-US/docs/Web/HTML/Element/section
 */
final class Section extends AbstractElement implements ParentElementInterface
{
    public function __construct(AttributeSet $attributes = null, ElementSet $children = null)
    {
        $this->attributes = $attributes ?? new AttributeSet();
        $this->children = $children ?? new ElementSet();
        $this->tag = new Standard('section', $attributes, $children);
    }

    public function withAttribute(string $name, string $value = null): Section
    {
        if ($value) {
            $attribute = new StandardAttribute($name, $value);
        } else {
            $attribute = new BooleanAttribute($name);
        }

        return new Section($this->attributes->add($attribute), $this->children);
    }

    public function withChild(ElementInterface $element): Section
    {
        return new Section($this->attributes, $this->children->add($element));
    }
}



 * Class Shadow
 * @see https://developer.mozilla.org/en-US/docs/Web/HTML/Element/shadow
 */
final class Shadow extends AbstractElement implements ParentElementInterface
{
    public function __construct(AttributeSet $attributes = null, ElementSet $children = null)
    {
        $this->attributes = $attributes ?? new AttributeSet();
        $this->children = $children ?? new ElementSet();
        $this->tag = new Standard('shadow', $attributes, $children);
    }

    public function withAttribute(string $name, string $value = null): Shadow
    {
        if ($value) {
            $attribute = new StandardAttribute($name, $value);
        } else {
            $attribute = new BooleanAttribute($name);
        }

        return new Shadow($this->attributes->add($attribute), $this->children);
    }

    public function withChild(ElementInterface $element): Shadow
    {
        return new Shadow($this->attributes, $this->children->add($element));
    }
}



 * Class Small
 * @see https://developer.mozilla.org/en-US/docs/Web/HTML/Element/small
 */
final class Small extends AbstractElement implements ParentElementInterface
{
    public function __construct(AttributeSet $attributes = null, ElementSet $children = null)
    {
        $this->attributes = $attributes ?? new AttributeSet();
        $this->children = $children ?? new ElementSet();
        $this->tag = new Standard('small', $attributes, $children);
    }

    public function withAttribute(string $name, string $value = null): Small
    {
        if ($value) {
            $attribute = new StandardAttribute($name, $value);
        } else {
            $attribute = new BooleanAttribute($name);
        }

        return new Small($this->attributes->add($attribute), $this->children);
    }

    public function withChild(ElementInterface $element): Small
    {
        return new Small($this->attributes, $this->children->add($element));
    }
}



 * Class Span
 * @see https://developer.mozilla.org/en-US/docs/Web/HTML/Element/span
 */
final class Span extends AbstractElement implements ParentElementInterface
{
    public function __construct(AttributeSet $attributes = null, ElementSet $children = null)
    {
        $this->attributes = $attributes ?? new AttributeSet();
        $this->children = $children ?? new ElementSet();
        $this->tag = new Standard('span', $attributes, $children);
    }

    public function withAttribute(string $name, string $value = null): Span
    {
        if ($value) {
            $attribute = new StandardAttribute($name, $value);
        } else {
            $attribute = new BooleanAttribute($name);
        }

        return new Span($this->attributes->add($attribute), $this->children);
    }

    public function withChild(ElementInterface $element): Span
    {
        return new Span($this->attributes, $this->children->add($element));
    }
}



 * Class Strike
 * @see https://developer.mozilla.org/en-US/docs/Web/HTML/Element/s
 */
final class Strike extends AbstractElement implements ParentElementInterface
{
    public function __construct(AttributeSet $attributes = null, ElementSet $children = null)
    {
        $this->attributes = $attributes ?? new AttributeSet();
        $this->children = $children ?? new ElementSet();
        $this->tag = new Standard('s', $attributes, $children);
    }

    public function withAttribute(string $name, string $value = null): Strike
    {
        if ($value) {
            $attribute = new StandardAttribute($name, $value);
        } else {
            $attribute = new BooleanAttribute($name);
        }

        return new Strike($this->attributes->add($attribute), $this->children);
    }

    public function withChild(ElementInterface $element): Strike
    {
        return new Strike($this->attributes, $this->children->add($element));
    }
}



 * Class Strong
 * @see https://developer.mozilla.org/en-US/docs/Web/HTML/Element/strong
 */
final class Strong extends AbstractElement implements ParentElementInterface
{
    public function __construct(AttributeSet $attributes = null, ElementSet $children = null)
    {
        $this->attributes = $attributes ?? new AttributeSet();
        $this->children = $children ?? new ElementSet();
        $this->tag = new Standard('strong', $attributes, $children);
    }

    public function withAttribute(string $name, string $value = null): Strong
    {
        if ($value) {
            $attribute = new StandardAttribute($name, $value);
        } else {
            $attribute = new BooleanAttribute($name);
        }

        return new Strong($this->attributes->add($attribute), $this->children);
    }

    public function withChild(ElementInterface $element): Strong
    {
        return new Strong($this->attributes, $this->children->add($element));
    }
}



 * Class Subscript
 * @see https://developer.mozilla.org/en-US/docs/Web/HTML/Element/sub
 */
final class Subscript extends AbstractElement implements ParentElementInterface
{
    public function __construct(AttributeSet $attributes = null, ElementSet $children = null)
    {
        $this->attributes = $attributes ?? new AttributeSet();
        $this->children = $children ?? new ElementSet();
        $this->tag = new Standard('sub', $attributes, $children);
    }

    public function withAttribute(string $name, string $value = null): Subscript
    {
        if ($value) {
            $attribute = new StandardAttribute($name, $value);
        } else {
            $attribute = new BooleanAttribute($name);
        }

        return new Subscript($this->attributes->add($attribute), $this->children);
    }

    public function withChild(ElementInterface $element): Subscript
    {
        return new Subscript($this->attributes, $this->children->add($element));
    }
}



 * Class Summary
 * @see https://developer.mozilla.org/en-US/docs/Web/HTML/Element/summary
 */
final class Summary extends AbstractElement implements ParentElementInterface
{
    public function __construct(AttributeSet $attributes = null, ElementSet $children = null)
    {
        $this->attributes = $attributes ?? new AttributeSet();
        $this->children = $children ?? new ElementSet();
        $this->tag = new Standard('summary', $attributes, $children);
    }

    public function withAttribute(string $name, string $value = null): Summary
    {
        if ($value) {
            $attribute = new StandardAttribute($name, $value);
        } else {
            $attribute = new BooleanAttribute($name);
        }

        return new Summary($this->attributes->add($attribute), $this->children);
    }

    public function withChild(ElementInterface $element): Summary
    {
        return new Summary($this->attributes, $this->children->add($element));
    }
}



 * Class Superscript
 * @see https://developer.mozilla.org/en-US/docs/Web/HTML/Element/sup
 */
final class Superscript extends AbstractElement implements ParentElementInterface
{
    public function __construct(AttributeSet $attributes = null, ElementSet $children = null)
    {
        $this->attributes = $attributes ?? new AttributeSet();
        $this->children = $children ?? new ElementSet();
        $this->tag = new Standard('sup', $attributes, $children);
    }

    public function withAttribute(string $name, string $value = null): Superscript
    {
        if ($value) {
            $attribute = new StandardAttribute($name, $value);
        } else {
            $attribute = new BooleanAttribute($name);
        }

        return new Superscript($this->attributes->add($attribute), $this->children);
    }

    public function withChild(ElementInterface $element): Superscript
    {
        return new Superscript($this->attributes, $this->children->add($element));
    }
}



 * Class Table
 * @see https://developer.mozilla.org/en-US/docs/Web/HTML/Element/table
 */
final class Table extends AbstractElement implements ParentElementInterface
{
    public function __construct(AttributeSet $attributes = null, ElementSet $children = null)
    {
        $this->attributes = $attributes ?? new AttributeSet();
        $this->children = $children ?? new ElementSet();
        $this->tag = new Standard('table', $attributes, $children);
    }

    public function withAttribute(string $name, string $value = null): Table
    {
        if ($value) {
            $attribute = new StandardAttribute($name, $value);
        } else {
            $attribute = new BooleanAttribute($name);
        }

        return new Table($this->attributes->add($attribute), $this->children);
    }

    public function withChild(ElementInterface $element): Table
    {
        return new Table($this->attributes, $this->children->add($element));
    }
}



 * Class TableBody
 * @see https://developer.mozilla.org/en-US/docs/Web/HTML/Element/tbody
 */
final class TableBody extends AbstractElement implements ParentElementInterface
{
    public function __construct(AttributeSet $attributes = null, ElementSet $children = null)
    {
        $this->attributes = $attributes ?? new AttributeSet();
        $this->children = $children ?? new ElementSet();
        $this->tag = new Standard('tbody', $attributes, $children);
    }

    public function withAttribute(string $name, string $value = null): TableBody
    {
        if ($value) {
            $attribute = new StandardAttribute($name, $value);
        } else {
            $attribute = new BooleanAttribute($name);
        }

        return new TableBody($this->attributes->add($attribute), $this->children);
    }

    public function withChild(ElementInterface $element): TableBody
    {
        return new TableBody($this->attributes, $this->children->add($element));
    }
}



 * Class TableFoot
 * @see https://developer.mozilla.org/en-US/docs/Web/HTML/Element/tfoot
 */
final class TableFoot extends AbstractElement implements ParentElementInterface
{
    public function __construct(AttributeSet $attributes = null, ElementSet $children = null)
    {
        $this->attributes = $attributes ?? new AttributeSet();
        $this->children = $children ?? new ElementSet();
        $this->tag = new Standard('tfoot', $attributes, $children);
    }

    public function withAttribute(string $name, string $value = null): TableFoot
    {
        if ($value) {
            $attribute = new StandardAttribute($name, $value);
        } else {
            $attribute = new BooleanAttribute($name);
        }

        return new TableFoot($this->attributes->add($attribute), $this->children);
    }

    public function withChild(ElementInterface $element): TableFoot
    {
        return new TableFoot($this->attributes, $this->children->add($element));
    }
}



 * Class TableHeader
 * @see https://developer.mozilla.org/en-US/docs/Web/HTML/Element/thead
 */
final class TableHeader extends AbstractElement implements ParentElementInterface
{
    public function __construct(AttributeSet $attributes = null, ElementSet $children = null)
    {
        $this->attributes = $attributes ?? new AttributeSet();
        $this->children = $children ?? new ElementSet();
        $this->tag = new Standard('thead', $attributes, $children);
    }

    public function withAttribute(string $name, string $value = null): TableHeader
    {
        if ($value) {
            $attribute = new StandardAttribute($name, $value);
        } else {
            $attribute = new BooleanAttribute($name);
        }

        return new TableHeader($this->attributes->add($attribute), $this->children);
    }

    public function withChild(ElementInterface $element): TableHeader
    {
        return new TableHeader($this->attributes, $this->children->add($element));
    }
}



 * Class TableRow
 * @see https://developer.mozilla.org/en-US/docs/Web/HTML/Element/tr
 */
final class TableRow extends AbstractElement implements ParentElementInterface
{
    public function __construct(AttributeSet $attributes = null, ElementSet $children = null)
    {
        $this->attributes = $attributes ?? new AttributeSet();
        $this->children = $children ?? new ElementSet();
        $this->tag = new Standard('tr', $attributes, $children);
    }

    public function withAttribute(string $name, string $value = null): TableRow
    {
        if ($value) {
            $attribute = new StandardAttribute($name, $value);
        } else {
            $attribute = new BooleanAttribute($name);
        }

        return new TableRow($this->attributes->add($attribute), $this->children);
    }

    public function withChild(ElementInterface $element): TableRow
    {
        return new TableRow($this->attributes, $this->children->add($element));
    }
}



 * Class Template
 * @see https://developer.mozilla.org/en-US/docs/Web/HTML/Element/template
 */
final class Template extends AbstractElement implements ParentElementInterface
{
    public function __construct(AttributeSet $attributes = null, ElementSet $children = null)
    {
        $this->attributes = $attributes ?? new AttributeSet();
        $this->children = $children ?? new ElementSet();
        $this->tag = new Standard('template', $attributes, $children);
    }

    public function withAttribute(string $name, string $value = null): Template
    {
        if ($value) {
            $attribute = new StandardAttribute($name, $value);
        } else {
            $attribute = new BooleanAttribute($name);
        }

        return new Template($this->attributes->add($attribute), $this->children);
    }

    public function withChild(ElementInterface $element): Template
    {
        return new Template($this->attributes, $this->children->add($element));
    }
}



 * Class Time
 * @see https://developer.mozilla.org/en-US/docs/Web/HTML/Element/time
 */
final class Time extends AbstractElement implements ParentElementInterface
{
    public function __construct(AttributeSet $attributes = null, ElementSet $children = null)
    {
        $this->attributes = $attributes ?? new AttributeSet();
        $this->children = $children ?? new ElementSet();
        $this->tag = new Standard('time', $attributes, $children);
    }

    public function withAttribute(string $name, string $value = null): Time
    {
        if ($value) {
            $attribute = new StandardAttribute($name, $value);
        } else {
            $attribute = new BooleanAttribute($name);
        }

        return new Time($this->attributes->add($attribute), $this->children);
    }

    public function withChild(ElementInterface $element): Time
    {
        return new Time($this->attributes, $this->children->add($element));
    }

    /**
     * @see http://www.w3.org/TR/html-markup/datatypes.html#common.data.datetime
     */
    public function withDateTime(string $dateTime): Time
    {
        return $this->withAttribute('datetime', $dateTime);
    }
}



 * Class Title
 * @see https://developer.mozilla.org/en-US/docs/Web/HTML/Element/title
 */
final class Title extends AbstractElement implements ParentElementInterface
{
    public function __construct(AttributeSet $attributes = null, ElementSet $children = null)
    {
        $this->attributes = $attributes ?? new AttributeSet();
        $this->children = $children ?? new ElementSet();
        $this->tag = new Standard('title', $attributes, $children);
    }

    public function withAttribute(string $name, string $value = null): Title
    {
        if ($value) {
            $attribute = new StandardAttribute($name, $value);
        } else {
            $attribute = new BooleanAttribute($name);
        }

        return new Title($this->attributes->add($attribute), $this->children);
    }

    public function withChild(ElementInterface $element): Title
    {
        return new Title($this->attributes, $this->children->add($element));
    }
}



 * Class Underline
 * @see https://developer.mozilla.org/en-US/docs/Web/HTML/Element/u
 */
final class Underline extends AbstractElement implements ParentElementInterface
{
    public function __construct(AttributeSet $attributes = null, ElementSet $children = null)
    {
        $this->attributes = $attributes ?? new AttributeSet();
        $this->children = $children ?? new ElementSet();
        $this->tag = new Standard('u', $attributes, $children);
    }

    public function withAttribute(string $name, string $value = null): Underline
    {
        if ($value) {
            $attribute = new StandardAttribute($name, $value);
        } else {
            $attribute = new BooleanAttribute($name);
        }

        return new Underline($this->attributes->add($attribute), $this->children);
    }

    public function withChild(ElementInterface $element): Underline
    {
        return new Underline($this->attributes, $this->children->add($element));
    }
}



 * Class UnorderedList
 * @see https://developer.mozilla.org/en-US/docs/Web/HTML/Element/ul
 */
final class UnorderedList extends AbstractElement implements ParentElementInterface
{
    public function __construct(AttributeSet $attributes = null, ElementSet $children = null)
    {
        $this->attributes = $attributes ?? new AttributeSet();
        $this->children = $children ?? new ElementSet();
        $this->tag = new Standard('ul', $attributes, $children);
    }

    public function withAttribute(string $name, string $value = null): UnorderedList
    {
        if ($value) {
            $attribute = new StandardAttribute($name, $value);
        } else {
            $attribute = new BooleanAttribute($name);
        }

        return new UnorderedList($this->attributes->add($attribute), $this->children);
    }

    public function withChild(ElementInterface $element): UnorderedList
    {
        return new UnorderedList($this->attributes, $this->children->add($element));
    }
}



 * Class Variable
 * @see https://developer.mozilla.org/en-US/docs/Web/HTML/Element/var
 */
final class Variable extends AbstractElement implements ParentElementInterface
{
    public function __construct(AttributeSet $attributes = null, ElementSet $children = null)
    {
        $this->attributes = $attributes ?? new AttributeSet();
        $this->children = $children ?? new ElementSet();
        $this->tag = new Standard('var', $attributes, $children);
    }

    public function withAttribute(string $name, string $value = null): Variable
    {
        if ($value) {
            $attribute = new StandardAttribute($name, $value);
        } else {
            $attribute = new BooleanAttribute($name);
        }

        return new Variable($this->attributes->add($attribute), $this->children);
    }

    public function withChild(ElementInterface $element): Variable
    {
        return new Variable($this->attributes, $this->children->add($element));
    }
}


		@@ 15-45 (lines=31) @@
12		* Class Abbreviation
13		* @see https://developer.mozilla.org/en-US/docs/Web/HTML/Element/abbr
14		*/
15		final class Abbreviation extends AbstractElement implements ParentElementInterface
16		{
17		public function __construct(AttributeSet $attributes = null, ElementSet $children = null)
18		{
19		$this->attributes = $attributes ?? new AttributeSet();
20		$this->children = $children ?? new ElementSet();
21
22		$this->tag = new Standard('abbr', $attributes, $children);
23		}
24
25		public function withAttribute(string $name, string $value = null): Abbreviation
26		{
27		if ($value) {
28		$attribute = new StandardAttribute($name, $value);
29		} else {
30		$attribute = new BooleanAttribute($name);
31		}
32
33		return new Abbreviation($this->attributes->add($attribute), $this->children);
34		}
35
36		public function withChild(ElementInterface $element): Abbreviation
37		{
38		return new Abbreviation($this->attributes, $this->children->add($element));
39		}
40
41		public function withTitle(string $title): Abbreviation
42		{
43		return $this->withAttribute('title', $title);
44		}
45		}
46

		@@ 15-40 (lines=26) @@
12		* Class Address
13		* @see https://developer.mozilla.org/en-US/docs/Web/HTML/Element/address
14		*/
15		final class Address extends AbstractElement
16		{
17		public function __construct(AttributeSet $attributes = null, ElementSet $children = null)
18		{
19		$this->attributes = $attributes ?? new AttributeSet();
20		$this->children = $children ?? new ElementSet();
21
22		$this->tag = new Standard('address', $attributes, $children);
23		}
24
25		public function withAttribute(string $name, string $value = null): Address
26		{
27		if ($value) {
28		$attribute = new StandardAttribute($name, $value);
29		} else {
30		$attribute = new BooleanAttribute($name);
31		}
32
33		return new Address($this->attributes->add($attribute), $this->children);
34		}
35
36		public function withChild(ElementInterface $element): Address
37		{
38		return new Address($this->attributes, $this->children->add($element));
39		}
40		}
41

		@@ 15-39 (lines=25) @@
12		* Class Article
13		* @see https://developer.mozilla.org/en-US/docs/Web/HTML/Element/article
14		*/
15		final class Article extends AbstractElement implements ParentElementInterface
16		{
17		public function __construct(AttributeSet $attributes = null, ElementSet $children = null)
18		{
19		$this->attributes = $attributes ?? new AttributeSet();
20		$this->children = $children ?? new ElementSet();
21		$this->tag = new Standard('article', $attributes, $children);
22		}
23
24		public function withAttribute(string $name, string $value = null): Article
25		{
26		if ($value) {
27		$attribute = new StandardAttribute($name, $value);
28		} else {
29		$attribute = new BooleanAttribute($name);
30		}
31
32		return new Article($this->attributes->add($attribute), $this->children);
33		}
34
35		public function withChild(ElementInterface $element): Article
36		{
37		return new Article($this->attributes, $this->children->add($element));
38		}
39		}
40

		@@ 15-39 (lines=25) @@
12		* Class Aside
13		* @see https://developer.mozilla.org/en-US/docs/Web/HTML/Element/aside
14		*/
15		final class Aside extends AbstractElement implements ParentElementInterface
16		{
17		public function __construct(AttributeSet $attributes = null, ElementSet $children = null)
18		{
19		$this->attributes = $attributes ?? new AttributeSet();
20		$this->children = $children ?? new ElementSet();
21		$this->tag = new Standard('aside', $attributes, $children);
22		}
23
24		public function withAttribute(string $name, string $value = null): Aside
25		{
26		if ($value) {
27		$attribute = new StandardAttribute($name, $value);
28		} else {
29		$attribute = new BooleanAttribute($name);
30		}
31
32		return new Aside($this->attributes->add($attribute), $this->children);
33		}
34
35		public function withChild(ElementInterface $element): Aside
36		{
37		return new Aside($this->attributes, $this->children->add($element));
38		}
39		}
40

		@@ 15-39 (lines=25) @@
12		* Class B
13		* @see https://developer.mozilla.org/en-US/docs/Web/HTML/Element/b
14		*/
15		final class B extends AbstractElement implements ParentElementInterface
16		{
17		public function __construct(AttributeSet $attributes = null, ElementSet $children = null)
18		{
19		$this->attributes = $attributes ?? new AttributeSet();
20		$this->children = $children ?? new ElementSet();
21		$this->tag = new Standard('b', $attributes, $children);
22		}
23
24		public function withAttribute(string $name, string $value = null): B
25		{
26		if ($value) {
27		$attribute = new StandardAttribute($name, $value);
28		} else {
29		$attribute = new BooleanAttribute($name);
30		}
31
32		return new B($this->attributes->add($attribute), $this->children);
33		}
34
35		public function withChild(ElementInterface $element): B
36		{
37		return new B($this->attributes, $this->children->add($element));
38		}
39		}
40

		@@ 15-39 (lines=25) @@
12		* Class BiDirectionalIsolation
13		* @see https://developer.mozilla.org/en-US/docs/Web/HTML/Element/bdi
14		*/
15		final class BiDirectionalIsolation extends AbstractElement implements ParentElementInterface
16		{
17		public function __construct(AttributeSet $attributes = null, ElementSet $children = null)
18		{
19		$this->attributes = $attributes ?? new AttributeSet();
20		$this->children = $children ?? new ElementSet();
21		$this->tag = new Standard('bdi', $attributes, $children);
22		}
23
24		public function withAttribute(string $name, string $value = null): BiDirectionalIsolation
25		{
26		if ($value) {
27		$attribute = new StandardAttribute($name, $value);
28		} else {
29		$attribute = new BooleanAttribute($name);
30		}
31
32		return new BiDirectionalIsolation($this->attributes->add($attribute), $this->children);
33		}
34
35		public function withChild(ElementInterface $element): BiDirectionalIsolation
36		{
37		return new BiDirectionalIsolation($this->attributes, $this->children->add($element));
38		}
39		}
40

		@@ 15-44 (lines=30) @@
12		* Class BiDirectionalOverride
13		* @see https://developer.mozilla.org/en-US/docs/Web/HTML/Element/bdo
14		*/
15		final class BiDirectionalOverride extends AbstractElement implements ParentElementInterface
16		{
17		public function __construct(AttributeSet $attributes = null, ElementSet $children = null)
18		{
19		$this->attributes = $attributes ?? new AttributeSet();
20		$this->children = $children ?? new ElementSet();
21		$this->tag = new Standard('bdo', $attributes, $children);
22		}
23
24		public function withAttribute(string $name, string $value = null): BiDirectionalOverride
25		{
26		if ($value) {
27		$attribute = new StandardAttribute($name, $value);
28		} else {
29		$attribute = new BooleanAttribute($name);
30		}
31
32		return new BiDirectionalOverride($this->attributes->add($attribute), $this->children);
33		}
34
35		public function withChild(ElementInterface $element): BiDirectionalOverride
36		{
37		return new BiDirectionalOverride($this->attributes, $this->children->add($element));
38		}
39
40		public function withDir(string $direction = 'auto'): BiDirectionalOverride
41		{
42		return $this->withAttribute('dir', $direction);
43		}
44		}
45

		@@ 15-44 (lines=30) @@
12		* Class BlockQuote
13		* @see https://developer.mozilla.org/en-US/docs/Web/HTML/Element/blockquote
14		*/
15		final class BlockQuote extends AbstractElement implements ParentElementInterface
16		{
17		public function __construct(AttributeSet $attributes = null, ElementSet $children = null)
18		{
19		$this->attributes = $attributes ?? new AttributeSet();
20		$this->children = $children ?? new ElementSet();
21		$this->tag = new Standard('blockquote', $attributes, $children);
22		}
23
24		public function withAttribute(string $name, string $value = null): BlockQuote
25		{
26		if ($value) {
27		$attribute = new StandardAttribute($name, $value);
28		} else {
29		$attribute = new BooleanAttribute($name);
30		}
31
32		return new BlockQuote($this->attributes->add($attribute), $this->children);
33		}
34
35		public function withChild(ElementInterface $element): BlockQuote
36		{
37		return new BlockQuote($this->attributes, $this->children->add($element));
38		}
39
40		public function withCite(string $url): BlockQuote
41		{
42		return $this->withAttribute('cite', $url);
43		}
44		}
45

		@@ 15-39 (lines=25) @@
12		* Class Body
13		* @see https://developer.mozilla.org/en-US/docs/Web/HTML/Element/body
14		*/
15		final class Body extends AbstractElement implements ParentElementInterface
16		{
17		public function __construct(AttributeSet $attributes = null, ElementSet $children = null)
18		{
19		$this->attributes = $attributes ?? new AttributeSet();
20		$this->children = $children ?? new ElementSet();
21		$this->tag = new Standard('body', $attributes, $children);
22		}
23
24		public function withAttribute(string $name, string $value = null): Body
25		{
26		if ($value) {
27		$attribute = new StandardAttribute($name, $value);
28		} else {
29		$attribute = new BooleanAttribute($name);
30		}
31
32		return new Body($this->attributes->add($attribute), $this->children);
33		}
34
35		public function withChild(ElementInterface $element): Body
36		{
37		return new Body($this->attributes, $this->children->add($element));
38		}
39		}
40

		@@ 15-39 (lines=25) @@
12		* Class Caption
13		* @see https://developer.mozilla.org/en-US/docs/Web/HTML/Element/caption
14		*/
15		final class Caption extends AbstractElement implements ParentElementInterface
16		{
17		public function __construct(AttributeSet $attributes = null, ElementSet $children = null)
18		{
19		$this->attributes = $attributes ?? new AttributeSet();
20		$this->children = $children ?? new ElementSet();
21		$this->tag = new Standard('caption', $attributes, $children);
22		}
23
24		public function withAttribute(string $name, string $value = null): Caption
25		{
26		if ($value) {
27		$attribute = new StandardAttribute($name, $value);
28		} else {
29		$attribute = new BooleanAttribute($name);
30		}
31
32		return new Caption($this->attributes->add($attribute), $this->children);
33		}
34
35		public function withChild(ElementInterface $element): Caption
36		{
37		return new Caption($this->attributes, $this->children->add($element));
38		}
39		}
40

		@@ 15-39 (lines=25) @@
12		* Class Cite
13		* @see https://developer.mozilla.org/en-US/docs/Web/HTML/Element/cite
14		*/
15		final class Cite extends AbstractElement implements ParentElementInterface
16		{
17		public function __construct(AttributeSet $attributes = null, ElementSet $children = null)
18		{
19		$this->attributes = $attributes ?? new AttributeSet();
20		$this->children = $children ?? new ElementSet();
21		$this->tag = new Standard('cite', $attributes, $children);
22		}
23
24		public function withAttribute(string $name, string $value = null): Cite
25		{
26		if ($value) {
27		$attribute = new StandardAttribute($name, $value);
28		} else {
29		$attribute = new BooleanAttribute($name);
30		}
31
32		return new Cite($this->attributes->add($attribute), $this->children);
33		}
34
35		public function withChild(ElementInterface $element): Cite
36		{
37		return new Cite($this->attributes, $this->children->add($element));
38		}
39		}
40

		@@ 15-39 (lines=25) @@
12		* Class Code
13		* @see https://developer.mozilla.org/en-US/docs/Web/HTML/Element/code
14		*/
15		final class Code extends AbstractElement implements ParentElementInterface
16		{
17		public function __construct(AttributeSet $attributes = null, ElementSet $children = null)
18		{
19		$this->attributes = $attributes ?? new AttributeSet();
20		$this->children = $children ?? new ElementSet();
21		$this->tag = new Standard('code', $attributes, $children);
22		}
23
24		public function withAttribute(string $name, string $value = null): Code
25		{
26		if ($value) {
27		$attribute = new StandardAttribute($name, $value);
28		} else {
29		$attribute = new BooleanAttribute($name);
30		}
31
32		return new Code($this->attributes->add($attribute), $this->children);
33		}
34
35		public function withChild(ElementInterface $element): Code
36		{
37		return new Code($this->attributes, $this->children->add($element));
38		}
39		}
40

		@@ 15-44 (lines=30) @@
12		* Class ColumnGroup
13		* @see https://developer.mozilla.org/en-US/docs/Web/HTML/Element/colgroup
14		*/
15		final class ColumnGroup extends AbstractElement implements ParentElementInterface
16		{
17		public function __construct(AttributeSet $attributes = null, ElementSet $children = null)
18		{
19		$this->attributes = $attributes ?? new AttributeSet();
20		$this->children = $children ?? new ElementSet();
21		$this->tag = new Standard('colgroup', $attributes, $children);
22		}
23
24		public function withAttribute(string $name, string $value = null): ColumnGroup
25		{
26		if ($value) {
27		$attribute = new StandardAttribute($name, $value);
28		} else {
29		$attribute = new BooleanAttribute($name);
30		}
31
32		return new ColumnGroup($this->attributes->add($attribute), $this->children);
33		}
34
35		public function withChild(ElementInterface $element): ColumnGroup
36		{
37		return new ColumnGroup($this->attributes, $this->children->add($element));
38		}
39
40		public function withSpan(int $span = 1): ColumnGroup
41		{
42		return $this->withAttribute('span', $span);
43		}
44		}
45

		@@ 15-44 (lines=30) @@
12		* Class Data
13		* @see https://developer.mozilla.org/en-US/docs/Web/HTML/Element/data
14		*/
15		final class Data extends AbstractElement implements ParentElementInterface
16		{
17		public function __construct(AttributeSet $attributes = null, ElementSet $children = null)
18		{
19		$this->attributes = $attributes ?? new AttributeSet();
20		$this->children = $children ?? new ElementSet();
21		$this->tag = new Standard('data', $attributes, $children);
22		}
23
24		public function withAttribute(string $name, string $value = null): Data
25		{
26		if ($value) {
27		$attribute = new StandardAttribute($name, $value);
28		} else {
29		$attribute = new BooleanAttribute($name);
30		}
31
32		return new Data($this->attributes->add($attribute), $this->children);
33		}
34
35		public function withChild(ElementInterface $element): Data
36		{
37		return new Data($this->attributes, $this->children->add($element));
38		}
39
40		public function withValue(string $value): Data
41		{
42		return $this->withAttribute('value', $value);
43		}
44		}
45

		@@ 15-39 (lines=25) @@
12		* Class DataList
13		* @see https://developer.mozilla.org/en-US/docs/Web/HTML/Element/datalist
14		*/
15		final class DataList extends AbstractElement implements ParentElementInterface
16		{
17		public function __construct(AttributeSet $attributes = null, ElementSet $children = null)
18		{
19		$this->attributes = $attributes ?? new AttributeSet();
20		$this->children = $children ?? new ElementSet();
21		$this->tag = new Standard('datalist', $attributes, $children);
22		}
23
24		public function withAttribute(string $name, string $value = null): DataList
25		{
26		if ($value) {
27		$attribute = new StandardAttribute($name, $value);
28		} else {
29		$attribute = new BooleanAttribute($name);
30		}
31
32		return new DataList($this->attributes->add($attribute), $this->children);
33		}
34
35		public function withChild(ElementInterface $element): DataList
36		{
37		return new DataList($this->attributes, $this->children->add($element));
38		}
39		}
40

		@@ 15-39 (lines=25) @@
12		* Class Definition
13		* @see https://developer.mozilla.org/en-US/docs/Web/HTML/Element/dfn
14		*/
15		final class Definition extends AbstractElement implements ParentElementInterface
16		{
17		public function __construct(AttributeSet $attributes = null, ElementSet $children = null)
18		{
19		$this->attributes = $attributes ?? new AttributeSet();
20		$this->children = $children ?? new ElementSet();
21		$this->tag = new Standard('dfn', $attributes, $children);
22		}
23
24		public function withAttribute(string $name, string $value = null): Definition
25		{
26		if ($value) {
27		$attribute = new StandardAttribute($name, $value);
28		} else {
29		$attribute = new BooleanAttribute($name);
30		}
31
32		return new Definition($this->attributes->add($attribute), $this->children);
33		}
34
35		public function withChild(ElementInterface $element): Definition
36		{
37		return new Definition($this->attributes, $this->children->add($element));
38		}
39		}
40

		@@ 15-39 (lines=25) @@
12		* Class Description
13		* @see https://developer.mozilla.org/en-US/docs/Web/HTML/Element/dd
14		*/
15		final class Description extends AbstractElement implements ParentElementInterface
16		{
17		public function __construct(AttributeSet $attributes = null, ElementSet $children = null)
18		{
19		$this->attributes = $attributes ?? new AttributeSet();
20		$this->children = $children ?? new ElementSet();
21		$this->tag = new Standard('dd', $attributes, $children);
22		}
23
24		public function withAttribute(string $name, string $value = null): Description
25		{
26		if ($value) {
27		$attribute = new StandardAttribute($name, $value);
28		} else {
29		$attribute = new BooleanAttribute($name);
30		}
31
32		return new Description($this->attributes->add($attribute), $this->children);
33		}
34
35		public function withChild(ElementInterface $element): Description
36		{
37		return new Description($this->attributes, $this->children->add($element));
38		}
39		}
40

		@@ 15-39 (lines=25) @@
12		* Class DescriptionList
13		* @see https://developer.mozilla.org/en-US/docs/Web/HTML/Element/dl
14		*/
15		final class DescriptionList extends AbstractElement implements ParentElementInterface
16		{
17		public function __construct(AttributeSet $attributes = null, ElementSet $children = null)
18		{
19		$this->attributes = $attributes ?? new AttributeSet();
20		$this->children = $children ?? new ElementSet();
21		$this->tag = new Standard('dl', $attributes, $children);
22		}
23
24		public function withAttribute(string $name, string $value = null): DescriptionList
25		{
26		if ($value) {
27		$attribute = new StandardAttribute($name, $value);
28		} else {
29		$attribute = new BooleanAttribute($name);
30		}
31
32		return new DescriptionList($this->attributes->add($attribute), $this->children);
33		}
34
35		public function withChild(ElementInterface $element): DescriptionList
36		{
37		return new DescriptionList($this->attributes, $this->children->add($element));
38		}
39		}
40

		@@ 15-39 (lines=25) @@
12		* Class DescriptionTerm
13		* @see https://developer.mozilla.org/en-US/docs/Web/HTML/Element/dt
14		*/
15		final class DescriptionTerm extends AbstractElement implements ParentElementInterface
16		{
17		public function __construct(AttributeSet $attributes = null, ElementSet $children = null)
18		{
19		$this->attributes = $attributes ?? new AttributeSet();
20		$this->children = $children ?? new ElementSet();
21		$this->tag = new Standard('dt', $attributes, $children);
22		}
23
24		public function withAttribute(string $name, string $value = null): DescriptionTerm
25		{
26		if ($value) {
27		$attribute = new StandardAttribute($name, $value);
28		} else {
29		$attribute = new BooleanAttribute($name);
30		}
31
32		return new DescriptionTerm($this->attributes->add($attribute), $this->children);
33		}
34
35		public function withChild(ElementInterface $element): DescriptionTerm
36		{
37		return new DescriptionTerm($this->attributes, $this->children->add($element));
38		}
39		}
40

		@@ 15-44 (lines=30) @@
12		* Class Details
13		* @see https://developer.mozilla.org/en-US/docs/Web/HTML/Element/details
14		*/
15		final class Details extends AbstractElement implements ParentElementInterface
16		{
17		public function __construct(AttributeSet $attributes = null, ElementSet $children = null)
18		{
19		$this->attributes = $attributes ?? new AttributeSet();
20		$this->children = $children ?? new ElementSet();
21		$this->tag = new Standard('details', $attributes, $children);
22		}
23
24		public function withAttribute(string $name, string $value = null): Details
25		{
26		if ($value) {
27		$attribute = new StandardAttribute($name, $value);
28		} else {
29		$attribute = new BooleanAttribute($name);
30		}
31
32		return new Details($this->attributes->add($attribute), $this->children);
33		}
34
35		public function withChild(ElementInterface $element): Details
36		{
37		return new Details($this->attributes, $this->children->add($element));
38		}
39
40		public function withOpen(string $open = 'false'): Details
41		{
42		return $this->withAttribute('open', $open);
43		}
44		}
45

		@@ 15-39 (lines=25) @@
12		* Class Division
13		* @see https://developer.mozilla.org/en-US/docs/Web/HTML/Element/div
14		*/
15		final class Division extends AbstractElement implements ParentElementInterface
16		{
17		public function __construct(AttributeSet $attributes = null, ElementSet $children = null)
18		{
19		$this->attributes = $attributes ?? new AttributeSet();
20		$this->children = $children ?? new ElementSet();
21		$this->tag = new Standard('div', $attributes, $children);
22		}
23
24		public function withAttribute(string $name, string $value = null): Division
25		{
26		if ($value) {
27		$attribute = new StandardAttribute($name, $value);
28		} else {
29		$attribute = new BooleanAttribute($name);
30		}
31
32		return new Division($this->attributes->add($attribute), $this->children);
33		}
34
35		public function withChild(ElementInterface $element): Division
36		{
37		return new Division($this->attributes, $this->children->add($element));
38		}
39		}
40

		@@ 15-39 (lines=25) @@
12		* Class Emphasis
13		* @see https://developer.mozilla.org/en-US/docs/Web/HTML/Element/em
14		*/
15		final class Emphasis extends AbstractElement
16		{
17		public function __construct(AttributeSet $attributes = null, ElementSet $children = null)
18		{
19		$this->attributes = $attributes ?? new AttributeSet();
20		$this->children = $children ?? new ElementSet();
21		$this->tag = new Standard('em', $attributes, $children);
22		}
23
24		public function withAttribute(string $name, string $value = null): Emphasis
25		{
26		if ($value) {
27		$attribute = new StandardAttribute($name, $value);
28		} else {
29		$attribute = new BooleanAttribute($name);
30		}
31
32		return new Emphasis($this->attributes->add($attribute), $this->children);
33		}
34
35		public function withChild(ElementInterface $element): Emphasis
36		{
37		return new Emphasis($this->attributes, $this->children->add($element));
38		}
39		}
40

		@@ 15-39 (lines=25) @@
12		* Class Figure
13		* @see https://developer.mozilla.org/en-US/docs/Web/HTML/Element/figure
14		*/
15		final class Figure extends AbstractElement implements ParentElementInterface
16		{
17		public function __construct(AttributeSet $attributes = null, ElementSet $children = null)
18		{
19		$this->attributes = $attributes ?? new AttributeSet();
20		$this->children = $children ?? new ElementSet();
21		$this->tag = new Standard('figure', $attributes, $children);
22		}
23
24		public function withAttribute(string $name, string $value = null): Figure
25		{
26		if ($value) {
27		$attribute = new StandardAttribute($name, $value);
28		} else {
29		$attribute = new BooleanAttribute($name);
30		}
31
32		return new Figure($this->attributes->add($attribute), $this->children);
33		}
34
35		public function withChild(ElementInterface $element): Figure
36		{
37		return new Figure($this->attributes, $this->children->add($element));
38		}
39		}
40

		@@ 15-39 (lines=25) @@
12		* Class FigureCaption
13		* @see https://developer.mozilla.org/en-US/docs/Web/HTML/Element/figcaption
14		*/
15		final class FigureCaption extends AbstractElement implements ParentElementInterface
16		{
17		public function __construct(AttributeSet $attributes = null, ElementSet $children = null)
18		{
19		$this->attributes = $attributes ?? new AttributeSet();
20		$this->children = $children ?? new ElementSet();
21		$this->tag = new Standard('figcaption', $attributes, $children);
22		}
23
24		public function withAttribute(string $name, string $value = null): FigureCaption
25		{
26		if ($value) {
27		$attribute = new StandardAttribute($name, $value);
28		} else {
29		$attribute = new BooleanAttribute($name);
30		}
31
32		return new FigureCaption($this->attributes->add($attribute), $this->children);
33		}
34
35		public function withChild(ElementInterface $element): FigureCaption
36		{
37		return new FigureCaption($this->attributes, $this->children->add($element));
38		}
39		}
40

		@@ 15-39 (lines=25) @@
12		* Class Footer
13		* @see https://developer.mozilla.org/en-US/docs/Web/HTML/Element/footer
14		*/
15		final class Footer extends AbstractElement implements ParentElementInterface
16		{
17		public function __construct(AttributeSet $attributes = null, ElementSet $children = null)
18		{
19		$this->attributes = $attributes ?? new AttributeSet();
20		$this->children = $children ?? new ElementSet();
21		$this->tag = new Standard('footer', $attributes, $children);
22		}
23
24		public function withAttribute(string $name, string $value = null): Footer
25		{
26		if ($value) {
27		$attribute = new StandardAttribute($name, $value);
28		} else {
29		$attribute = new BooleanAttribute($name);
30		}
31
32		return new Footer($this->attributes->add($attribute), $this->children);
33		}
34
35		public function withChild(ElementInterface $element): Footer
36		{
37		return new Footer($this->attributes, $this->children->add($element));
38		}
39		}
40

royallthefourth / html-document

Code Duplication Length = 25-33 lines in 65 locations

src/Element/Abbreviation.php 1 location

src/Element/Address.php 1 location

src/Element/Article.php 1 location

src/Element/Aside.php 1 location

src/Element/B.php 1 location

src/Element/BiDirectionalIsolation.php 1 location

src/Element/BiDirectionalOverride.php 1 location

src/Element/BlockQuote.php 1 location

src/Element/Body.php 1 location

src/Element/Caption.php 1 location

src/Element/Cite.php 1 location

src/Element/Code.php 1 location

src/Element/ColumnGroup.php 1 location

src/Element/Data.php 1 location

src/Element/DataList.php 1 location

src/Element/Definition.php 1 location

src/Element/Description.php 1 location

src/Element/DescriptionList.php 1 location

src/Element/DescriptionTerm.php 1 location

src/Element/Details.php 1 location

src/Element/Division.php 1 location

src/Element/Emphasis.php 1 location

src/Element/Figure.php 1 location

src/Element/FigureCaption.php 1 location

src/Element/Footer.php 1 location

src/Element/Head.php 1 location

src/Element/Header.php 1 location

src/Element/Html.php 1 location

src/Element/I.php 1 location

src/Element/Keyboard.php 1 location

src/Element/Label.php 1 location

src/Element/Legend.php 1 location

src/Element/ListItem.php 1 location

src/Element/Main.php 1 location

src/Element/Map.php 1 location

src/Element/Mark.php 1 location

src/Element/Nav.php 1 location

src/Element/NoScript.php 1 location

src/Element/Paragraph.php 1 location

src/Element/Pre.php 1 location

src/Element/Quote.php 1 location

src/Element/Rp.php 1 location

src/Element/Rt.php 1 location

src/Element/Ruby.php 1 location

src/Element/Sample.php 1 location

src/Element/Section.php 1 location

src/Element/Shadow.php 1 location

src/Element/Small.php 1 location

src/Element/Span.php 1 location

src/Element/Strike.php 1 location

src/Element/Strong.php 1 location

src/Element/Subscript.php 1 location

src/Element/Summary.php 1 location

src/Element/Superscript.php 1 location

src/Element/Table.php 1 location

src/Element/TableBody.php 1 location

src/Element/TableFoot.php 1 location

src/Element/TableHeader.php 1 location

src/Element/TableRow.php 1 location

src/Element/Template.php 1 location

src/Element/Time.php 1 location

src/Element/Title.php 1 location

src/Element/Underline.php 1 location

src/Element/UnorderedList.php 1 location

src/Element/Variable.php 1 location

		@@ 15-39 (lines=25) @@
12		* Class Head
13		* @see https://developer.mozilla.org/en-US/docs/Web/HTML/Element/head
14		*/
15		final class Head extends AbstractElement implements ParentElementInterface
16		{
17		public function __construct(AttributeSet $attributes = null, ElementSet $children = null)
18		{
19		$this->attributes = $attributes ?? new AttributeSet();
20		$this->children = $children ?? new ElementSet();
21		$this->tag = new Standard('head', $attributes, $children);
22		}
23
24		public function withAttribute(string $name, string $value = null): Head
25		{
26		if ($value) {
27		$attribute = new StandardAttribute($name, $value);
28		} else {
29		$attribute = new BooleanAttribute($name);
30		}
31
32		return new Head($this->attributes->add($attribute), $this->children);
33		}
34
35		public function withChild(ElementInterface $element): Head
36		{
37		return new Head($this->attributes, $this->children->add($element));
38		}
39		}
40

		@@ 15-39 (lines=25) @@
12		* Class Header
13		* @see https://developer.mozilla.org/en-US/docs/Web/HTML/Element/header
14		*/
15		final class Header extends AbstractElement implements ParentElementInterface
16		{
17		public function __construct(AttributeSet $attributes = null, ElementSet $children = null)
18		{
19		$this->attributes = $attributes ?? new AttributeSet();
20		$this->children = $children ?? new ElementSet();
21		$this->tag = new Standard('header', $attributes, $children);
22		}
23
24		public function withAttribute(string $name, string $value = null): Header
25		{
26		if ($value) {
27		$attribute = new StandardAttribute($name, $value);
28		} else {
29		$attribute = new BooleanAttribute($name);
30		}
31
32		return new Header($this->attributes->add($attribute), $this->children);
33		}
34
35		public function withChild(ElementInterface $element): Header
36		{
37		return new Header($this->attributes, $this->children->add($element));
38		}
39		}
40

		@@ 15-39 (lines=25) @@
12		* Class Html
13		* @see https://developer.mozilla.org/en-US/docs/Web/HTML/Element/html
14		*/
15		final class Html extends AbstractElement implements ParentElementInterface
16		{
17		public function __construct(AttributeSet $attributes = null, ElementSet $children = null)
18		{
19		$this->attributes = $attributes ?? new AttributeSet();
20		$this->children = $children ?? new ElementSet();
21		$this->tag = new Standard('html', $attributes, $children);
22		}
23
24		public function withAttribute(string $name, string $value = null): Html
25		{
26		if ($value) {
27		$attribute = new StandardAttribute($name, $value);
28		} else {
29		$attribute = new BooleanAttribute($name);
30		}
31
32		return new Html($this->attributes->add($attribute), $this->children);
33		}
34
35		public function withChild(ElementInterface $element): Html
36		{
37		return new Html($this->attributes, $this->children->add($element));
38		}
39		}
40

		@@ 15-39 (lines=25) @@
12		* Class I
13		* @see https://developer.mozilla.org/en-US/docs/Web/HTML/Element/i
14		*/
15		final class I extends AbstractElement implements ParentElementInterface
16		{
17		public function __construct(AttributeSet $attributes = null, ElementSet $children = null)
18		{
19		$this->attributes = $attributes ?? new AttributeSet();
20		$this->children = $children ?? new ElementSet();
21		$this->tag = new Standard('i', $attributes, $children);
22		}
23
24		public function withAttribute(string $name, string $value = null): I
25		{
26		if ($value) {
27		$attribute = new StandardAttribute($name, $value);
28		} else {
29		$attribute = new BooleanAttribute($name);
30		}
31
32		return new I($this->attributes->add($attribute), $this->children);
33		}
34
35		public function withChild(ElementInterface $element): I
36		{
37		return new I($this->attributes, $this->children->add($element));
38		}
39		}
40

		@@ 15-39 (lines=25) @@
12		* Class Keyboard
13		* @see https://developer.mozilla.org/en-US/docs/Web/HTML/Element/kbd
14		*/
15		final class Keyboard extends AbstractElement implements ParentElementInterface
16		{
17		public function __construct(AttributeSet $attributes = null, ElementSet $children = null)
18		{
19		$this->attributes = $attributes ?? new AttributeSet();
20		$this->children = $children ?? new ElementSet();
21		$this->tag = new Standard('kbd', $attributes, $children);
22		}
23
24		public function withAttribute(string $name, string $value = null): Keyboard
25		{
26		if ($value) {
27		$attribute = new StandardAttribute($name, $value);
28		} else {
29		$attribute = new BooleanAttribute($name);
30		}
31
32		return new Keyboard($this->attributes->add($attribute), $this->children);
33		}
34
35		public function withChild(ElementInterface $element): Keyboard
36		{
37		return new Keyboard($this->attributes, $this->children->add($element));
38		}
39		}
40

		@@ 15-44 (lines=30) @@
12		* Class Label
13		* @see https://developer.mozilla.org/en-US/docs/Web/HTML/Element/label
14		*/
15		final class Label extends AbstractElement implements ParentElementInterface
16		{
17		public function __construct(AttributeSet $attributes = null, ElementSet $children = null)
18		{
19		$this->attributes = $attributes ?? new AttributeSet();
20		$this->children = $children ?? new ElementSet();
21		$this->tag = new Standard('label', $attributes, $children);
22		}
23
24		public function withAttribute(string $name, string $value = null): Label
25		{
26		if ($value) {
27		$attribute = new StandardAttribute($name, $value);
28		} else {
29		$attribute = new BooleanAttribute($name);
30		}
31
32		return new Label($this->attributes->add($attribute), $this->children);
33		}
34
35		public function withChild(ElementInterface $element): Label
36		{
37		return new Label($this->attributes, $this->children->add($element));
38		}
39
40		public function withFor(string $id): Label
41		{
42		return $this->withAttribute('for', $id);
43		}
44		}
45

		@@ 15-39 (lines=25) @@
12		* Class Legend
13		* @see https://developer.mozilla.org/en-US/docs/Web/HTML/Element/legend
14		*/
15		final class Legend extends AbstractElement implements ParentElementInterface
16		{
17		public function __construct(AttributeSet $attributes = null, ElementSet $children = null)
18		{
19		$this->attributes = $attributes ?? new AttributeSet();
20		$this->children = $children ?? new ElementSet();
21		$this->tag = new Standard('legend', $attributes, $children);
22		}
23
24		public function withAttribute(string $name, string $value = null): Legend
25		{
26		if ($value) {
27		$attribute = new StandardAttribute($name, $value);
28		} else {
29		$attribute = new BooleanAttribute($name);
30		}
31
32		return new Legend($this->attributes->add($attribute), $this->children);
33		}
34
35		public function withChild(ElementInterface $element): Legend
36		{
37		return new Legend($this->attributes, $this->children->add($element));
38		}
39		}
40

		@@ 15-44 (lines=30) @@
12		* Class ListItem
13		* @see https://developer.mozilla.org/en-US/docs/Web/HTML/Element/li
14		*/
15		final class ListItem extends AbstractElement implements ParentElementInterface
16		{
17		public function __construct(AttributeSet $attributes = null, ElementSet $children = null)
18		{
19		$this->attributes = $attributes ?? new AttributeSet();
20		$this->children = $children ?? new ElementSet();
21		$this->tag = new Standard('li', $attributes, $children);
22		}
23
24		public function withAttribute(string $name, string $value = null): ListItem
25		{
26		if ($value) {
27		$attribute = new StandardAttribute($name, $value);
28		} else {
29		$attribute = new BooleanAttribute($name);
30		}
31
32		return new ListItem($this->attributes->add($attribute), $this->children);
33		}
34
35		public function withChild(ElementInterface $element): ListItem
36		{
37		return new ListItem($this->attributes, $this->children->add($element));
38		}
39
40		public function withValue(int $value): ListItem
41		{
42		return $this->withAttribute('value', $value);
43		}
44		}
45

		@@ 15-39 (lines=25) @@
12		* Class Main
13		* @see https://developer.mozilla.org/en-US/docs/Web/HTML/Element/main
14		*/
15		final class Main extends AbstractElement implements ParentElementInterface
16		{
17		public function __construct(AttributeSet $attributes = null, ElementSet $children = null)
18		{
19		$this->attributes = $attributes ?? new AttributeSet();
20		$this->children = $children ?? new ElementSet();
21		$this->tag = new Standard('main', $attributes, $children);
22		}
23
24		public function withAttribute(string $name, string $value = null): Main
25		{
26		if ($value) {
27		$attribute = new StandardAttribute($name, $value);
28		} else {
29		$attribute = new BooleanAttribute($name);
30		}
31
32		return new Main($this->attributes->add($attribute), $this->children);
33		}
34
35		public function withChild(ElementInterface $element): Main
36		{
37		return new Main($this->attributes, $this->children->add($element));
38		}
39		}
40

		@@ 15-44 (lines=30) @@
12		* Class Map
13		* @see https://developer.mozilla.org/en-US/docs/Web/HTML/Element/map
14		*/
15		final class Map extends AbstractElement implements ParentElementInterface
16		{
17		public function __construct(AttributeSet $attributes = null, ElementSet $children = null)
18		{
19		$this->attributes = $attributes ?? new AttributeSet();
20		$this->children = $children ?? new ElementSet();
21		$this->tag = new Standard('map', $attributes, $children);
22		}
23
24		public function withAttribute(string $name, string $value = null): Map
25		{
26		if ($value) {
27		$attribute = new StandardAttribute($name, $value);
28		} else {
29		$attribute = new BooleanAttribute($name);
30		}
31
32		return new Map($this->attributes->add($attribute), $this->children);
33		}
34
35		public function withChild(ElementInterface $element): Map
36		{
37		return new Map($this->attributes, $this->children->add($element));
38		}
39
40		public function withName(string $name): Map
41		{
42		return $this->withAttribute('name', $name);
43		}
44		}
45