Yiisoft\Html\Html

Complexity

Total Complexity

275

Size/Duplication

Total Lines	1853
Duplicated Lines	0 %

Test Coverage

Coverage

100%

Importance

Changes	19
Bugs	1	Features	0

102 Methods

Rating	Name	Duplication	Size	Complexity
A	h2()	0	7	3
A	article()	0	7	3
A	h1()	0	7	3
A	thead()	0	4	2
A	tbody()	0	4	2
A	col()	0	4	2
A	label()	0	10	3
A	encodeUnquotedAttribute()	0	20	1
A	section()	0	7	3
A	td()	0	10	3
A	strong()	0	7	3
A	fieldset()	0	7	2
A	javaScriptFile()	0	7	2
A	colgroup()	0	4	2
A	i()	0	7	3
A	cssFile()	0	7	2
A	th()	0	10	3
A	form()	0	13	4
A	encode()	0	7	1
A	p()	0	7	3
A	input()	0	17	4
A	hiddenInput()	0	7	2
A	closeTag()	0	3	1
A	resetButton()	0	7	2
A	video()	0	3	1
A	tr()	0	4	2
A	submitButton()	0	7	2
A	h4()	0	7	3
A	radioList()	0	3	1
A	optgroup()	0	3	1
A	h3()	0	7	3
A	resetInput()	0	7	2
A	ol()	0	7	2
A	hgroup()	0	7	3
A	h5()	0	7	3
A	span()	0	7	3
A	table()	0	4	2
A	div()	0	7	3
A	voidTag()	0	7	2
A	img()	0	13	4
A	textInput()	0	7	2
A	escapeJavaScriptStringValue()	0	7	1
A	mailto()	0	9	2
A	source()	0	3	1
A	ul()	0	7	2
A	normalTag()	0	10	3
A	br()	0	3	1
A	option()	0	12	3
A	openTag()	0	3	1
A	checkbox()	0	7	2
A	body()	0	7	3
A	legend()	0	10	3
A	b()	0	7	3
A	select()	0	7	2
A	em()	0	7	3
A	html()	0	13	4
A	h6()	0	7	3
A	nav()	0	7	3
A	small()	0	7	3
A	tfoot()	0	4	2
A	range()	0	7	2
A	script()	0	10	3
A	track()	0	4	2
A	radio()	0	7	2
A	header()	0	7	3
A	picture()	0	3	1
A	file()	0	7	2
A	caption()	0	10	3
A	buttonInput()	0	7	2
A	generateId()	0	10	2
A	audio()	0	3	1
A	style()	0	10	3
A	a()	0	13	4
A	button()	0	7	2
A	noscript()	0	4	2
A	link()	0	10	3
A	tag()	0	10	3
A	textarea()	0	10	4
A	aside()	0	7	3
A	datalist()	0	7	2
A	title()	0	7	3
A	li()	0	4	2
A	submitInput()	0	7	2
A	passwordInput()	0	7	2
A	checkboxList()	0	3	1
A	meta()	0	7	2
A	encodeAttribute()	0	11	1
A	getNonArrayableName()	0	3	2
C	renderTagAttributes()	0	50	16
A	address()	0	7	3
A	getArrayableName()	0	3	2
B	addCssStyle()	0	16	8
A	mergeCssClasses()	0	11	5
A	removeCssClass()	0	18	5
A	normalizeRegexpPattern()	0	20	5
A	cssStyleFromArray()	0	9	3
B	addCssClass()	0	24	7
A	cssStyleToArray()	0	11	3
A	renderAttribute()	0	8	2
A	footer()	0	7	3
A	removeCssStyle()	0	9	4
A	hr()	0	7	2

<?php

declare(strict_types=1);

namespace Yiisoft\Html;

use InvalidArgumentException;
use JsonException;
use Stringable;
use Yiisoft\Html\Tag\A;
use Yiisoft\Html\Tag\Address;
use Yiisoft\Html\Tag\Article;
use Yiisoft\Html\Tag\Aside;
use Yiisoft\Html\Tag\B;
use Yiisoft\Html\Tag\Br;
use Yiisoft\Html\Tag\Button;
use Yiisoft\Html\Tag\Caption;
use Yiisoft\Html\Tag\Col;
use Yiisoft\Html\Tag\Colgroup;
use Yiisoft\Html\Tag\CustomTag;
use Yiisoft\Html\Tag\Datalist;
use Yiisoft\Html\Tag\Div;
use Yiisoft\Html\Tag\Em;
use Yiisoft\Html\Tag\Fieldset;
use Yiisoft\Html\Tag\Form;
use Yiisoft\Html\Tag\H1;
use Yiisoft\Html\Tag\H2;
use Yiisoft\Html\Tag\H3;
use Yiisoft\Html\Tag\H4;
use Yiisoft\Html\Tag\H5;
use Yiisoft\Html\Tag\H6;
use Yiisoft\Html\Tag\I;
use Yiisoft\Html\Tag\Img;
use Yiisoft\Html\Tag\Input;
use Yiisoft\Html\Tag\Input\Checkbox;
use Yiisoft\Html\Tag\Input\File;
use Yiisoft\Html\Tag\Input\Radio;
use Yiisoft\Html\Tag\Input\Range;
use Yiisoft\Html\Tag\Label;
use Yiisoft\Html\Tag\Legend;
use Yiisoft\Html\Tag\Li;
use Yiisoft\Html\Tag\Link;
use Yiisoft\Html\Tag\Audio;
use Yiisoft\Html\Tag\Body;
use Yiisoft\Html\Tag\Footer;
use Yiisoft\Html\Tag\Header;
use Yiisoft\Html\Tag\Hgroup;
use Yiisoft\Html\Tag\Hr;
use Yiisoft\Html\Tag\Small;
use Yiisoft\Html\Tag\Track;
use Yiisoft\Html\Tag\Video;
use Yiisoft\Html\Tag\Meta;
use Yiisoft\Html\Tag\Nav;
use Yiisoft\Html\Tag\Noscript;
use Yiisoft\Html\Tag\Ol;
use Yiisoft\Html\Tag\Optgroup;
use Yiisoft\Html\Tag\Option;
use Yiisoft\Html\Tag\P;
use Yiisoft\Html\Tag\Picture;
use Yiisoft\Html\Tag\Script;
use Yiisoft\Html\Tag\Section;
use Yiisoft\Html\Tag\Select;
use Yiisoft\Html\Tag\Source;
use Yiisoft\Html\Tag\Span;
use Yiisoft\Html\Tag\Strong;
use Yiisoft\Html\Tag\Style;
use Yiisoft\Html\Tag\Table;
use Yiisoft\Html\Tag\Tbody;
use Yiisoft\Html\Tag\Td;
use Yiisoft\Html\Tag\Textarea;
use Yiisoft\Html\Tag\Tfoot;
use Yiisoft\Html\Tag\Th;
use Yiisoft\Html\Tag\Thead;
use Yiisoft\Html\Tag\Title;
use Yiisoft\Html\Tag\Tr;
use Yiisoft\Html\Tag\Ul;
use Yiisoft\Html\Widget\CheckboxList\CheckboxList;
use Yiisoft\Html\Widget\RadioList\RadioList;
use Yiisoft\Json\Json;

use function count;
use function in_array;
use function is_array;
use function is_bool;
use function is_int;
use function strlen;

/**
 * Html provides a set of static methods for generating commonly used HTML tags.
 *
 * Nearly all the methods in this class allow setting additional HTML attributes for the HTML tags they generate.
 * You can specify, for example, `class`, `style` or `id` for an HTML element using the `$options` parameter. See the
 * documentation of the {@see tag()} method for more details.
 */
final class Html
{
    /**
     * The preferred order of attributes in a tag. This mainly affects the order of the attributes that are
     * rendered by {@see renderTagAttributes()}.
     */
    private const ATTRIBUTE_ORDER = [
        'type',
        'id',
        'class',
        'name',
        'value',

        'href',
        'src',
        'srcset',
        'form',
        'action',
        'method',

        'selected',
        'checked',
        'readonly',
        'disabled',
        'multiple',

        'size',
        'maxlength',
        'minlength',
        'width',
        'height',
        'rows',
        'cols',

        'alt',
        'title',
        'rel',
        'media',
    ];

    /**
     * List of tag attributes that should be specially handled when their values are of array type.
     * In particular, if the value of the `data` attribute is `['name' => 'xyz', 'age' => 13]`, two attributes will be
     * generated instead of one: `data-name="xyz" data-age="13"`.
     */
    private const DATA_ATTRIBUTES = ['data', 'data-ng', 'ng', 'aria'];

    /**
     * @var array<string, int>
     */
    private static array $generateIdCounter = [];

    /**
     * Returns an autogenerated sequential ID.
     *
     * @return string Autogenerated ID.
     */
    public static function generateId(string $prefix = 'i'): string
    {
        $prefix .= hrtime(true);
        if (isset(self::$generateIdCounter[$prefix])) {
            $counter = ++self::$generateIdCounter[$prefix];
        } else {
            $counter = 1;
            self::$generateIdCounter = [$prefix => $counter];
        }
        return $prefix . $counter;
    }

    /**
     * Encodes special characters into HTML entities for use as a tag content
     * i.e. `<div>tag content</div>`.
     * Characters encoded are: &, <, >.
     *
     * @param mixed $content The content to be encoded.
     * @param bool $doubleEncode If already encoded entities should be encoded.
     * @param string $encoding The encoding to use, defaults to "UTF-8".
     *
     * @return string Encoded content.
     *
     * @link https://html.spec.whatwg.org/#data-state
     */
    public static function encode(mixed $content, bool $doubleEncode = true, string $encoding = 'UTF-8'): string
    {
        return htmlspecialchars(
            (string) $content,
            ENT_NOQUOTES | ENT_SUBSTITUTE | ENT_HTML5,
            $encoding,
            $doubleEncode
        );
    }

    /**
     * Encodes special characters into HTML entities for use as HTML tag unquoted attribute value
     * i.e. `<input value=my-value>`.
     * Characters encoded are: &, <, >, ", ', `, =, tab, space, U+000A (form feed), U+0000 (null).
     *
     * @param mixed $value The attribute value to be encoded.
     * @param bool $doubleEncode If already encoded entities should be encoded.
     * @param string $encoding The encoding to use, defaults to "UTF-8".
     *
     * @return string Encoded attribute value.
     *
     * @link https://html.spec.whatwg.org/#attribute-value-(unquoted)-state
     * @link https://html.spec.whatwg.org/#attribute-value-(single-quoted)-state
     * @link https://html.spec.whatwg.org/#attribute-value-(double-quoted)-state
     */
    public static function encodeUnquotedAttribute(
        mixed $value,
        bool $doubleEncode = true,
        string $encoding = 'UTF-8'
    ): string {
        $value = htmlspecialchars(
            (string) $value,
            ENT_QUOTES | ENT_SUBSTITUTE | ENT_HTML5,
            $encoding,
            $doubleEncode
        );

        return strtr($value, [
            "\t" => '&Tab;', // U+0009 CHARACTER TABULATION (tab)
            "\n" => '&NewLine;', // U+000A LINE FEED (LF)
            "\u{000c}" => '&#12;', // U+000C FORM FEED (FF)
            "\u{0000}" => '&#0;', // U+0000 NULL
            ' ' => '&#32;', // U+0020 SPACE
            '=' => '&equals;', // U+003D EQUALS SIGN (=)
            '`' => '&grave;', // U+0060 GRAVE ACCENT (`)
        ]);
    }

    /**
     * Encodes special characters into HTML entities for use as HTML tag quoted attribute value
     * i.e. `<input value="my-value">`.
     * Characters encoded are: &, <, >, ", ', U+0000 (null).
     *
     * @param mixed $value The attribute value to be encoded.
     * @param bool $doubleEncode If already encoded entities should be encoded.
     * @param string $encoding The encoding to use, defaults to "UTF-8".
     *
     * @return string Encoded attribute value.
     *
     * @link https://html.spec.whatwg.org/#attribute-value-(single-quoted)-state
     * @link https://html.spec.whatwg.org/#attribute-value-(double-quoted)-state
     */
    public static function encodeAttribute(mixed $value, bool $doubleEncode = true, string $encoding = 'UTF-8'): string
    {
        $value = htmlspecialchars(
            (string) $value,
            ENT_QUOTES | ENT_SUBSTITUTE | ENT_HTML5,
            $encoding,
            $doubleEncode
        );

        return strtr($value, [
            "\u{0000}" => '&#0;', // U+0000 NULL
        ]);
    }

    /**
     * Escape special characters for use as JavaScript string value in a `<script>` tag:
     *
     * ```
     * <script>
     *     window.myVar = "<?= Html::escapeJavaScriptStringValue($myVar) ?>";
     * </script>
     * ```
     *
     * @param mixed $value JavaScript string.
     *
     * @return string Escaped JavaScript string.
     */
    public static function escapeJavaScriptStringValue(mixed $value): string
    {
        return strtr((string) $value, [
            '/' => '\/',
            '"' => '\"',
            "'" => "\'",
            '\\' => '\\\\',
        ]);
    }

    /**
     * Generates a complete HTML tag.
     *
     * @see CustomTag
     *
     * @param string $name The tag name.
     * @param string|Stringable $content The tag content.
     * @param array $attributes The tag attributes in terms of name-value pairs.
     *
     * @psalm-param non-empty-string $name
     */
    public static function tag(string $name, string|Stringable $content = '', array $attributes = []): CustomTag
    {
        $tag = CustomTag::name($name);
        if ($content !== '') {
            $tag = $tag->content($content);
        }
        if (!empty($attributes)) {
            $tag = $tag->attributes($attributes);
        }
        return $tag;
    }

    /**
     * Generates a normal HTML tag.
     *
     * @see CustomTag
     *
     * @param string $name The tag name.
     * @param string|Stringable $content The tag content.
     * @param array $attributes The tag attributes in terms of name-value pairs.
     *
     * @psalm-param non-empty-string $name
     */
    public static function normalTag(string $name, string|Stringable $content = '', array $attributes = []): CustomTag
    {
        $tag = CustomTag::name($name)->normal();
        if ($content !== '') {
            $tag = $tag->content($content);
        }
        if (!empty($attributes)) {
            $tag = $tag->attributes($attributes);
        }
        return $tag;
    }

    /**
     * Generates a void HTML tag.
     *
     * @see CustomTag
     *
     * @param string $name The tag name.
     * @param array $attributes The tag attributes in terms of name-value pairs.
     *
     * @psalm-param non-empty-string $name
     */
    public static function voidTag(string $name, array $attributes = []): CustomTag
    {
        $tag = CustomTag::name($name)->void();
        if (!empty($attributes)) {
            $tag = $tag->attributes($attributes);
        }
        return $tag;
    }

    /**
     * Generates a start tag.
     *
     * @see self::closeTag()
     *
     * @param string $name The tag name.
     * @param array $attributes The tag attributes in terms of name-value pairs.
     */
    public static function openTag(string $name, array $attributes = []): string
    {
        return '<' . $name . self::renderTagAttributes($attributes) . '>';
    }

    /**
     * Generates an end tag.
     *
     * @see self::openTag()
     *
     * @param string $name The tag name.
     */
    public static function closeTag(string $name): string
    {
        return "</$name>";
    }

    /**
     * Generates a {@see Style} tag.
     *
     * @param string $content The style content.
     * @param array $attributes The tag attributes in terms of name-value pairs.
     */
    public static function style(string $content = '', array $attributes = []): Style
    {
        $tag = Style::tag();
        if ($content !== '') {
            $tag = $tag->content($content);
        }
        if (!empty($attributes)) {
            $tag = $tag->attributes($attributes);
        }
        return $tag;
    }

    /**
     * Generates a {@see Script} tag.
     *
     * @param string $content The script content.
     * @param array $attributes The tag attributes in terms of name-value pairs.
     */
    public static function script(string $content = '', array $attributes = []): Script
    {
        $tag = Script::tag();
        if ($content !== '') {
            $tag = $tag->content($content);
        }
        if (!empty($attributes)) {
            $tag = $tag->attributes($attributes);
        }
        return $tag;
    }

    /**
     * Generates a {@see Noscript} tag.
     *
     * @param string|Stringable $content Tag content.
     */
    public static function noscript(string|Stringable $content = ''): Noscript
    {
        $tag = Noscript::tag();
        return $content === '' ? $tag : $tag->content($content);
    }

    /**
     * Generates a {@see Title} tag.
     *
     * @param string|Stringable $content Tag content.
     * @param array $attributes The tag attributes in terms of name-value pairs.
     */
    public static function title(string|Stringable $content = '', array $attributes = []): Title
    {
        $tag = Title::tag();
        if (!empty($attributes)) {
            $tag = $tag->attributes($attributes);
        }
        return $content === '' ? $tag : $tag->content($content);
    }

    /**
     * Generates a {@see Meta} tag.
     *
     * @param array $attributes The tag attributes in terms of name-value pairs.
     */
    public static function meta(array $attributes = []): Meta
    {
        $tag = Meta::tag();
        if (!empty($attributes)) {
            $tag = $tag->attributes($attributes);
        }
        return $tag;
    }

    /**
     * Generates a {@see Link} tag.
     *
     * @param string|null $url The destination of the link.
     * @param array $attributes The tag attributes in terms of name-value pairs.
     */
    public static function link(?string $url = null, array $attributes = []): Link
    {
        $tag = Link::tag();
        if (!empty($attributes)) {
            $tag = $tag->attributes($attributes);
        }
        if ($url !== null) {
            $tag = $tag->url($url);
        }
        return $tag;
    }

    /**
     * Generates a {@see Link} tag that refers to an CSS file.
     *
     * @param string $url The URL of the CSS file.
     * @param array $attributes The tag attributes in terms of name-value pairs.
     */
    public static function cssFile(string $url, array $attributes = []): Link
    {
        $tag = Link::toCssFile($url);
        if (!empty($attributes)) {
            $tag = $tag->addAttributes($attributes);
        }
        return $tag;
    }

    /**
     * Generates a {@see Script} tag that refers to a JavaScript file.
     *
     * @param string $url The URL of the JavaScript file.
     * @param array $attributes The tag attributes in terms of name-value pairs.
     */
    public static function javaScriptFile(string $url, array $attributes = []): Script
    {
        $tag = Script::tag()->url($url);
        if (!empty($attributes)) {
            $tag = $tag->addAttributes($attributes);
        }
        return $tag;
    }

    /**
     * Generates a hyperlink tag.
     *
     * @param string|Stringable $content The tag content.
     * @param array $attributes The tag attributes in terms of name-value pairs.
     *
     * @see A
     */
    public static function a(string|Stringable $content = '', ?string $url = null, array $attributes = []): A
    {
        $tag = A::tag();
        if (!empty($attributes)) {
            $tag = $tag->attributes($attributes);
        }
        if ($content !== '') {
            $tag = $tag->content($content);
        }
        if ($url !== null) {
            $tag = $tag->url($url);
        }
        return $tag;
    }

    /**
     * Generates a mailto hyperlink tag.
     *
     * @param array $attributes The tag attributes in terms of name-value pairs.
     *
     * @see A
     */
    public static function mailto(string $content, ?string $mail = null, array $attributes = []): A
    {
        $tag = A::tag()
            ->content($content)
            ->mailto($mail ?? $content);
        if (!empty($attributes)) {
            $tag = $tag->addAttributes($attributes);
        }
        return $tag;
    }

    /**
     * Generates an {@see Img} tag.
     *
     * @param string|null $url The image URL.
     * @param string|null $alt Alt text.
     * @param array $attributes The tag attributes in terms of name-value pairs.
     */
    public static function img(?string $url = null, ?string $alt = '', array $attributes = []): Img
    {
        $tag = Img::tag();
        if (!empty($attributes)) {
            $tag = $tag->attributes($attributes);
        }
        if ($url !== null) {
            $tag = $tag->src($url);
        }
        if ($alt !== null) {
            $tag = $tag->alt($alt);
        }
        return $tag;
    }

    /**
     * Generates a {@see Fieldset} tag.
     *
     * @param array $attributes The tag attributes in terms of name-value pairs.
     */
    public static function fieldset(array $attributes = []): Fieldset
    {
        $tag = Fieldset::tag();
        if (!empty($attributes)) {
            $tag = $tag->attributes($attributes);
        }
        return $tag;
    }

    /**
     * Generates a {@see Form} tag.
     *
     * @param string|null $action The URL to use for form submission.
     * @param string|null $method The method attribute value.
     * @param array $attributes The tag attributes in terms of name-value pairs.
     */
    public static function form(?string $action = null, ?string $method = null, array $attributes = []): Form
    {
        $tag = Form::tag();
        if ($action !== null) {
            $attributes['action'] = $action;
        }
        if ($method !== null) {
            $attributes['method'] = $method;
        }
        if (!empty($attributes)) {
            $tag = $tag->attributes($attributes);
        }
        return $tag;
    }

    /**
     * Generates a {@see Label} tag.
     *
     * @param string|Stringable $content Label text.
     * @param string|null $for The ID of the HTML element that this label is associated with.
     * If this is null, the "for" attribute will not be generated.
     */
    public static function label(string|Stringable $content = '', ?string $for = null): Label
    {
        $tag = Label::tag();
        if ($for !== null) {
            $tag = $tag->forId($for);
        }
        if ($content !== '') {
            $tag = $tag->content($content);
        }
        return $tag;
    }

    /**
     * Generates a {@see Legend} tag.
     *
     * @param string|Stringable $content The tag content.
     * @param array $attributes The tag attributes in terms of name-value pairs.
     */
    public static function legend(string|Stringable $content = '', array $attributes = []): Legend
    {
        $tag = Legend::tag();
        if ($content !== '') {
            $tag = $tag->content($content);
        }
        if (!empty($attributes)) {
            $tag = $tag->attributes($attributes);
        }
        return $tag;
    }

    /**
     * Generates a button tag.
     *
     * @see Button::button()
     *
     * @param string $content The content enclosed within the button tag.
     * @param array $attributes The tag attributes in terms of name-value pairs.
     */
    public static function button(string $content = 'Button', array $attributes = []): Button
    {
        $tag = Button::button($content);
        if (!empty($attributes)) {
            $tag = $tag->addAttributes($attributes);
        }
        return $tag;
    }

    /**
     * Generates a submit button tag.
     *
     * @see Button::submit()
     *
     * @param string $content The content enclosed within the button tag.
     * @param array $attributes The tag attributes in terms of name-value pairs.
     */
    public static function submitButton(string $content = 'Submit', array $attributes = []): Button
    {
        $tag = Button::submit($content);
        if (!empty($attributes)) {
            $tag = $tag->addAttributes($attributes);
        }
        return $tag;
    }

    /**
     * Generates a reset button tag.
     *
     * @see Button::reset()
     *
     * @param string $content The content enclosed within the button tag.
     * @param array $attributes The tag attributes in terms of name-value pairs.
     */
    public static function resetButton(string $content = 'Reset', array $attributes = []): Button
    {
        $tag = Button::reset($content);
        if (!empty($attributes)) {
            $tag = $tag->addAttributes($attributes);
        }
        return $tag;
    }

    /**
     * Generates an {@see Input} type of the given type.
     *
     * @param string $type The type attribute.
     * @param string|null $name The name attribute. If it is `null`, the name attribute will not be generated.
     * @param bool|float|int|string|Stringable|null $value The value attribute. If it is `null`, the value
     * attribute will not be generated.
     * @param array $attributes The tag attributes in terms of name-value pairs.
     */
    public static function input(
        string $type,
        ?string $name = null,
        bool|float|int|string|Stringable|null $value = null,
        array $attributes = []
    ): Input {
        $tag = Input::tag()->type($type);
        if ($name !== null) {
            $tag = $tag->name($name);
        }
        if ($value !== null) {
            $tag = $tag->value($value);
        }
        if (!empty($attributes)) {
            $tag = $tag->addAttributes($attributes);
        }
        return $tag;
    }

    /**
     * Generates an {@see Input} button.
     *
     * @see Input::button()
     *
     * @param string|null $label The value attribute.
     * @param array $attributes The tag attributes in terms of name-value pairs.
     */
    public static function buttonInput(?string $label = 'Button', array $attributes = []): Input
    {
        $tag = Input::button($label);
        if (!empty($attributes)) {
            $tag = $tag->addAttributes($attributes);
        }
        return $tag;
    }

    /**
     * Generates submit {@see Input} button.
     *
     * @see Input::submitButton()
     *
     * @param string|null $label The value attribute.
     * @param array $attributes The tag attributes in terms of name-value pairs.
     */
    public static function submitInput(?string $label = 'Submit', array $attributes = []): Input
    {
        $tag = Input::submitButton($label);
        if (!empty($attributes)) {
            $tag = $tag->addAttributes($attributes);
        }
        return $tag;
    }

    /**
     * Generates a reset {@see Input} button.
     *
     * @see Input::resetButton()
     *
     * @param string|null $label The value attribute.
     * @param array $attributes The tag attributes in terms of name-value pairs.
     */
    public static function resetInput(?string $label = 'Reset', array $attributes = []): Input
    {
        $tag = Input::resetButton($label);
        if (!empty($attributes)) {
            $tag = $tag->addAttributes($attributes);
        }
        return $tag;
    }

    /**
     * Generates a text {@see Input} field.
     *
     * @param string|null $name The name attribute.
     * @param bool|float|int|string|Stringable|null $value The value attribute.
     * @param array $attributes The tag attributes in terms of name-value pairs.
     */
    public static function textInput(
        ?string $name = null,
        bool|float|int|string|Stringable|null $value = null,
        array $attributes = []
    ): Input {
        $tag = Input::text($name, $value);
        return $attributes === [] ? $tag : $tag->addAttributes($attributes);
    }

    /**
     * Generates a hidden input field.
     *
     * @see Input::hidden()
     *
     * @param string|null $name The name attribute.
     * @param bool|float|int|string|Stringable|null $value The value attribute.
     * @param array $attributes The tag attributes in terms of name-value pairs.
     */
    public static function hiddenInput(
        ?string $name = null,
        bool|float|int|string|Stringable|null $value = null,
        array $attributes = []
    ): Input {
        $tag = Input::hidden($name, $value);
        return $attributes === [] ? $tag : $tag->addAttributes($attributes);
    }

    /**
     * Generates a password input field.
     *
     * @see Input::password()
     *
     * @param string|null $name The name attribute.
     * @param bool|float|int|string|Stringable|null $value The value attribute.
     * @param array $attributes The tag attributes in terms of name-value pairs.
     */
    public static function passwordInput(
        ?string $name = null,
        bool|float|int|string|Stringable|null $value = null,
        array $attributes = []
    ): Input {
        $tag = Input::password($name, $value);
        return $attributes === [] ? $tag : $tag->addAttributes($attributes);
    }

    /**
     * Generates a file input field.
     *
     * To use a file input field, you should set the enclosing form's "enctype" attribute to be "multipart/form-data".
     * After the form is submitted, the uploaded file information can be obtained via $_FILES[$name]
     * (see PHP documentation).
     *
     * @see Input::file()
     *
     * @param string|null $name The name attribute.
     * @param bool|float|int|string|Stringable|null $value The value attribute.
     * @param array $attributes The tag attributes in terms of name-value pairs.
     */
    public static function file(
        ?string $name = null,
        bool|float|int|string|Stringable|null $value = null,
        array $attributes = []
    ): File {
        $tag = Input::file($name, $value);
        return $attributes === [] ? $tag : $tag->addAttributes($attributes);
    }

    /**
     * Generates a radio button {@see Input}.
     *
     * @see Input::radio()
     *
     * @param string|null $name The name attribute.
     * @param bool|float|int|string|Stringable|null $value The value attribute.
     * @param array $attributes The tag attributes in terms of name-value pairs.
     */
    public static function radio(
        ?string $name = null,
        bool|float|int|string|Stringable|null $value = null,
        array $attributes = []
    ): Radio {
        $tag = Input::radio($name, $value);
        return $attributes === [] ? $tag : $tag->addAttributes($attributes);
    }

    /**
     * Generates a range {@see Range}.
     *
     * @see Input::range()
     *
     * @param string|null $name The name attribute.
     * @param float|int|string|Stringable|null $value The value attribute.
     * @param array $attributes The tag attributes in terms of name-value pairs.
     */
    public static function range(
        ?string $name = null,
        float|int|string|Stringable|null $value = null,
        array $attributes = []
    ): Range {
        $tag = Input::range($name, $value);
        return $attributes === [] ? $tag : $tag->addAttributes($attributes);
    }

    /**
     * Generates a checkbox {@see Input}.
     *
     * @see Input::checkbox()
     *
     * @param string|null $name The name attribute.
     * @param bool|float|int|string|Stringable|null $value The value attribute.
     * @param array $attributes The tag attributes in terms of name-value pairs.
     */
    public static function checkbox(
        ?string $name = null,
        bool|float|int|string|Stringable|null $value = null,
        array $attributes = []
    ): Checkbox {
        $tag = Input::checkbox($name, $value);
        return $attributes === [] ? $tag : $tag->addAttributes($attributes);
    }

    /**
     * Generates a {@see Textarea} input.
     *
     * @param string|null $name The input name.
     * @param string|null $value The input value.
     * @param array $attributes The tag attributes in terms of name-value pairs.
     */
    public static function textarea(?string $name = null, ?string $value = null, array $attributes = []): Textarea
    {
        $tag = Textarea::tag();
        if ($name !== null) {
            $tag = $tag->name($name);
        }
        if (!empty($value)) {
            $tag = $tag->value($value);
        }
        return $attributes === [] ? $tag : $tag->addAttributes($attributes);
    }

    /**
     * Generates a {@see Select} tag.
     *
     * @param string|null $name The name attribute
     */
    public static function select(?string $name = null): Select
    {
        $tag = Select::tag();
        if ($name !== null) {
            $tag = $tag->name($name);
        }
        return $tag;
    }

    /**
     * Generates a {@see Optgroup} tag.
     */
    public static function optgroup(): Optgroup
    {
        return Optgroup::tag();
    }

    /**
     * Generates a {@see Option} tag.
     *
     * @param string|Stringable $content Tag content.
     * @param bool|float|int|string|Stringable|null $value The value attribute.
     */
    public static function option(
        string|Stringable $content = '',
        bool|float|int|string|Stringable|null $value = null
    ): Option {
        $tag = Option::tag();
        if ($content !== '') {
            $tag = $tag->content($content);
        }
        if ($value !== null) {
            $tag = $tag->value($value);
        }
        return $tag;
    }

    /**
     * Generates a list of checkboxes.
     *
     * @see CheckboxList
     */
    public static function checkboxList(string $name): CheckboxList
    {
        return CheckboxList::create($name);
    }

    /**
     * Generates a list of radio buttons.
     *
     * @see RadioList
     */
    public static function radioList(string $name): RadioList
    {
        return RadioList::create($name);
    }

    /**
     * Generates a {@see Div} tag.
     *
     * @param string|Stringable $content Tag content.
     * @param array $attributes The tag attributes in terms of name-value pairs.
     */
    public static function div(string|Stringable $content = '', array $attributes = []): Div
    {
        $tag = Div::tag();
        if (!empty($attributes)) {
            $tag = $tag->attributes($attributes);
        }
        return $content === '' ? $tag : $tag->content($content);
    }

    /**
     * Generates a {@see Span} tag.
     *
     * @param string|Stringable $content Tag content.
     * @param array $attributes The tag attributes in terms of name-value pairs.
     */
    public static function span(string|Stringable $content = '', array $attributes = []): Span
    {
        $tag = Span::tag();
        if (!empty($attributes)) {
            $tag = $tag->attributes($attributes);
        }
        return $content === '' ? $tag : $tag->content($content);
    }

    /**
     * Generates a {@see Em} tag.
     *
     * @param string|Stringable $content Tag content.
     * @param array $attributes The tag attributes in terms of name-value pairs.
     */
    public static function em(string|Stringable $content = '', array $attributes = []): Em
    {
        $tag = Em::tag();
        if (!empty($attributes)) {
            $tag = $tag->attributes($attributes);
        }
        return $content === '' ? $tag : $tag->content($content);
    }

    /**
     * Generates a {@see Strong} tag.
     *
     * @param string|Stringable $content Tag content.
     * @param array $attributes The tag attributes in terms of name-value pairs.
     */
    public static function strong(string|Stringable $content = '', array $attributes = []): Strong
    {
        $tag = Strong::tag();
        if (!empty($attributes)) {
            $tag = $tag->attributes($attributes);
        }
        return $content === '' ? $tag : $tag->content($content);
    }

    /**
     * Generates a {@see Small} tag.
     *
     * @param string|Stringable $content Tag content.
     * @param array $attributes The tag attributes in terms of name-value pairs.
     */
    public static function small(string|Stringable $content = '', array $attributes = []): Small
    {
        $tag = Small::tag();
        if (!empty($attributes)) {
            $tag = $tag->attributes($attributes);
        }
        return $content === '' ? $tag : $tag->content($content);
    }

    /**
     * Generates a {@see B} tag.
     *
     * @param string|Stringable $content Tag content.
     * @param array $attributes The tag attributes in terms of name-value pairs.
     */
    public static function b(string|Stringable $content = '', array $attributes = []): B
    {
        $tag = B::tag();
        if (!empty($attributes)) {
            $tag = $tag->attributes($attributes);
        }
        return $content === '' ? $tag : $tag->content($content);
    }

    /**
     * Generates a {@see I} tag.
     *
     * @param string|Stringable $content Tag content.
     * @param array $attributes The tag attributes in terms of name-value pairs.
     */
    public static function i(string|Stringable $content = '', array $attributes = []): I
    {
        $tag = I::tag();
        if (!empty($attributes)) {
            $tag = $tag->attributes($attributes);
        }
        return $content === '' ? $tag : $tag->content($content);
    }

    /**
     * Generates a {@see H1} tag.
     *
     * @param string|Stringable $content Tag content.
     * @param array $attributes The tag attributes in terms of name-value pairs.
     */
    public static function h1(string|Stringable $content = '', array $attributes = []): H1
    {
        $tag = H1::tag();
        if (!empty($attributes)) {
            $tag = $tag->attributes($attributes);
        }
        return $content === '' ? $tag : $tag->content($content);
    }

    /**
     * Generates a {@see H2} tag.
     *
     * @param string|Stringable $content Tag content.
     * @param array $attributes The tag attributes in terms of name-value pairs.
     */
    public static function h2(string|Stringable $content = '', array $attributes = []): H2
    {
        $tag = H2::tag();
        if (!empty($attributes)) {
            $tag = $tag->attributes($attributes);
        }
        return $content === '' ? $tag : $tag->content($content);
    }

    /**
     * Generates a {@see H3} tag.
     *
     * @param string|Stringable $content Tag content.
     * @param array $attributes The tag attributes in terms of name-value pairs.
     */
    public static function h3(string|Stringable $content = '', array $attributes = []): H3
    {
        $tag = H3::tag();
        if (!empty($attributes)) {
            $tag = $tag->attributes($attributes);
        }
        return $content === '' ? $tag : $tag->content($content);
    }

    /**
     * Generates a {@see H4} tag.
     *
     * @param string|Stringable $content Tag content.
     * @param array $attributes The tag attributes in terms of name-value pairs.
     */
    public static function h4(string|Stringable $content = '', array $attributes = []): H4
    {
        $tag = H4::tag();
        if (!empty($attributes)) {
            $tag = $tag->attributes($attributes);
        }
        return $content === '' ? $tag : $tag->content($content);
    }

    /**
     * Generates a {@see H5} tag.
     *
     * @param string|Stringable $content Tag content.
     * @param array $attributes The tag attributes in terms of name-value pairs.
     */
    public static function h5(string|Stringable $content = '', array $attributes = []): H5
    {
        $tag = H5::tag();
        if (!empty($attributes)) {
            $tag = $tag->attributes($attributes);
        }
        return $content === '' ? $tag : $tag->content($content);
    }

    /**
     * Generates a {@see H6} tag.
     *
     * @param string|Stringable $content Tag content.
     * @param array $attributes The tag attributes in terms of name-value pairs.
     */
    public static function h6(string|Stringable $content = '', array $attributes = []): H6
    {
        $tag = H6::tag();
        if (!empty($attributes)) {
            $tag = $tag->attributes($attributes);
        }
        return $content === '' ? $tag : $tag->content($content);
    }

    /**
     * Generates a {@see P} tag.
     *
     * @param string|Stringable $content Tag content.
     * @param array $attributes The tag attributes in terms of name-value pairs.
     */
    public static function p(string|Stringable $content = '', array $attributes = []): P
    {
        $tag = P::tag();
        if (!empty($attributes)) {
            $tag = $tag->attributes($attributes);
        }
        return $content === '' ? $tag : $tag->content($content);
    }

    /**
     * Generates a {@see Ul} tag.
     *
     * @param array $attributes The tag attributes in terms of name-value pairs.
     */
    public static function ul(array $attributes = []): Ul
    {
        $tag = Ul::tag();
        if (!empty($attributes)) {
            $tag = $tag->attributes($attributes);
        }
        return $tag;
    }

    /**
     * Generates a {@see Ol} tag.
     *
     * @param array $attributes The tag attributes in terms of name-value pairs.
     */
    public static function ol(array $attributes = []): Ol
    {
        $tag = Ol::tag();
        if (!empty($attributes)) {
            $tag = $tag->attributes($attributes);
        }
        return $tag;
    }

    /**
     * Generates a {@see Li} tag.
     *
     * @param string|Stringable $content Tag content.
     */
    public static function li(string|Stringable $content = ''): Li
    {
        $tag = Li::tag();
        return $content === '' ? $tag : $tag->content($content);
    }

    /**
     * Generates a {@see Datalist} tag.
     *
     * @param array $attributes The tag attributes in terms of name-value pairs.
     */
    public static function datalist(array $attributes = []): Datalist
    {
        $tag = Datalist::tag();
        if (!empty($attributes)) {
            $tag = $tag->attributes($attributes);
        }
        return $tag;
    }

    /**
     * Generates a {@see Caption} tag.
     *
     * @param string|Stringable $content Tag content.
     * @param array $attributes The tag attributes in terms of name-value pairs.
     */
    public static function caption(string|Stringable $content = '', array $attributes = []): Caption
    {
        $tag = Caption::tag();
        if ($content !== '') {
            $tag = $tag->content($content);
        }
        if ($attributes !== []) {
            $tag = $tag->attributes($attributes);
        }
        return $tag;
    }

    /**
     * Generates a {@see Col} tag.
     *
     * @param array $attributes The tag attributes in terms of name-value pairs.
     */
    public static function col(array $attributes = []): Col
    {
        $tag = Col::tag();
        return $attributes === [] ? $tag : $tag->attributes($attributes);
    }

    /**
     * Generates a {@see Colgroup} tag.
     *
     * @param array $attributes The tag attributes in terms of name-value pairs.
     */
    public static function colgroup(array $attributes = []): Colgroup
    {
        $tag = Colgroup::tag();
        return $attributes === [] ? $tag : $tag->attributes($attributes);
    }

    /**
     * Generates a {@see Table} tag.
     *
     * @param array $attributes The tag attributes in terms of name-value pairs.
     */
    public static function table(array $attributes = []): Table
    {
        $tag = Table::tag();
        return $attributes === [] ? $tag : $tag->attributes($attributes);
    }

    /**
     * Generates a {@see Thead} tag.
     *
     * @param array $attributes The tag attributes in terms of name-value pairs.
     */
    public static function thead(array $attributes = []): Thead
    {
        $tag = Thead::tag();
        return $attributes === [] ? $tag : $tag->attributes($attributes);
    }

    /**
     * Generates a {@see Tbody} tag.
     *
     * @param array $attributes The tag attributes in terms of name-value pairs.
     */
    public static function tbody(array $attributes = []): Tbody
    {
        $tag = Tbody::tag();
        return $attributes === [] ? $tag : $tag->attributes($attributes);
    }

    /**
     * Generates a {@see Tfoot} tag.
     *
     * @param array $attributes The tag attributes in terms of name-value pairs.
     */
    public static function tfoot(array $attributes = []): Tfoot
    {
        $tag = Tfoot::tag();
        return $attributes === [] ? $tag : $tag->attributes($attributes);
    }

    /**
     * Generates a {@see Tr} tag.
     *
     * @param array $attributes The tag attributes in terms of name-value pairs.
     */
    public static function tr(array $attributes = []): Tr
    {
        $tag = Tr::tag();
        return $attributes === [] ? $tag : $tag->attributes($attributes);
    }

    /**
     * Generates a {@see Td} tag.
     *
     * @param string|Stringable $content Tag content.
     * @param array $attributes The tag attributes in terms of name-value pairs.
     */
    public static function td(string|Stringable $content = '', array $attributes = []): Td
    {
        $tag = Td::tag();
        if ($content !== '') {
            $tag = $tag->content($content);
        }
        if ($attributes !== []) {
            $tag = $tag->attributes($attributes);
        }
        return $tag;
    }

    /**
     * Generates a {@see Th} tag.
     *
     * @param string|Stringable $content Tag content.
     * @param array $attributes The tag attributes in terms of name-value pairs.
     */
    public static function th(string|Stringable $content = '', array $attributes = []): Th
    {
        $tag = Th::tag();
        if ($content !== '') {
            $tag = $tag->content($content);
        }
        if ($attributes !== []) {
            $tag = $tag->attributes($attributes);
        }
        return $tag;
    }

    /**
     * Generates a {@see Br} tag.
     */
    public static function br(): Br
    {
        return Br::tag();
    }

    /**
     * Generates a {@see Video} tag.
     */
    public static function video(): Video
    {
        return Video::tag();
    }

    /**
     * Generates a {@see Audio} tag.
     */
    public static function audio(): Audio
    {
        return Audio::tag();
    }

    /**
     * Generates a {@see Track} tag.
     */
    public static function track(?string $src = null): Track
    {
        $tag = Track::tag();
        return $src === null ? $tag : $tag->src($src);
    }

    /**
     * Generates a {@see Picture} tag.
     */
    public static function picture(): Picture
    {
        return Picture::tag();
    }

    /**
     * Generates a {@see Source} tag.
     */
    public static function source(): Source
    {
        return Source::tag();
    }

    /**
     * Generates a {@see Html} tag.
     *
     * @param string|Stringable $content Tag content.
     * @param string|null $lang The document language.
     * @param array $attributes The tag attributes in terms of name-value pairs.
     */
    public static function html(string|Stringable $content = '', ?string $lang = null, array $attributes = []): Tag\Html
    {
        $tag = Tag\Html::tag();
        if (!empty($attributes)) {
            $tag = $tag->attributes($attributes);
        }
        if ($content !== '') {
            $tag = $tag->content($content);
        }
        if ($lang !== null) {
            $tag = $tag->lang($lang);
        }
        return $tag;
    }

    /**
     * Generates a {@see Body} tag.
     *
     * @param string|Stringable $content Tag content.
     * @param array $attributes The tag attributes in terms of name-value pairs.
     */
    public static function body(string|Stringable $content = '', array $attributes = []): Body
    {
        $tag = Body::tag();
        if (!empty($attributes)) {
            $tag = $tag->attributes($attributes);
        }
        return $content === '' ? $tag : $tag->content($content);
    }

    /**
     * Generates a {@see Article} tag.
     *
     * @param string|Stringable $content Tag content.
     * @param array $attributes The tag attributes in terms of name-value pairs.
     */
    public static function article(string|Stringable $content = '', array $attributes = []): Article
    {
        $tag = Article::tag();
        if (!empty($attributes)) {
            $tag = $tag->attributes($attributes);
        }
        return $content === '' ? $tag : $tag->content($content);
    }

    /**
     * Generates a {@see Section} tag.
     *
     * @param string|Stringable $content Tag content.
     * @param array $attributes The tag attributes in terms of name-value pairs.
     */
    public static function section(string|Stringable $content = '', array $attributes = []): Section
    {
        $tag = Section::tag();
        if (!empty($attributes)) {
            $tag = $tag->attributes($attributes);
        }
        return $content === '' ? $tag : $tag->content($content);
    }

    /**
     * Generates a {@see Nav} tag.
     *
     * @param string|Stringable $content Tag content.
     * @param array $attributes The tag attributes in terms of name-value pairs.
     */
    public static function nav(string|Stringable $content = '', array $attributes = []): Nav
    {
        $tag = Nav::tag();
        if (!empty($attributes)) {
            $tag = $tag->attributes($attributes);
        }
        return $content === '' ? $tag : $tag->content($content);
    }

    /**
     * Generates a {@see Aside} tag.
     *
     * @param string|Stringable $content Tag content.
     * @param array $attributes The tag attributes in terms of name-value pairs.
     */
    public static function aside(string|Stringable $content = '', array $attributes = []): Aside
    {
        $tag = Aside::tag();
        if (!empty($attributes)) {
            $tag = $tag->attributes($attributes);
        }
        return $content === '' ? $tag : $tag->content($content);
    }

    /**
     * Generates a {@see Hgroup} tag.
     *
     * @param string|Stringable $content Tag content.
     * @param array $attributes The tag attributes in terms of name-value pairs.
     */
    public static function hgroup(string|Stringable $content = '', array $attributes = []): Hgroup
    {
        $tag = Hgroup::tag();
        if (!empty($attributes)) {
            $tag = $tag->attributes($attributes);
        }
        return $content === '' ? $tag : $tag->content($content);
    }

    /**
     * Generates a {@see Header} tag.
     *
     * @param string|Stringable $content Tag content.
     * @param array $attributes The tag attributes in terms of name-value pairs.
     */
    public static function header(string|Stringable $content = '', array $attributes = []): Header
    {
        $tag = Header::tag();
        if (!empty($attributes)) {
            $tag = $tag->attributes($attributes);
        }
        return $content === '' ? $tag : $tag->content($content);
    }

    /**
     * Generates a {@see Hr} tag.
     */
    public static function hr(array $attributes = []): Hr
    {
        $tag = Hr::tag();
        if (!empty($attributes)) {
            $tag = $tag->attributes($attributes);
        }
        return $tag;
    }

    /**
     * Generates a {@see Footer} tag.
     *
     * @param string|Stringable $content Tag content.
     * @param array $attributes The tag attributes in terms of name-value pairs.
     */
    public static function footer(string|Stringable $content = '', array $attributes = []): Footer
    {
        $tag = Footer::tag();
        if (!empty($attributes)) {
            $tag = $tag->attributes($attributes);
        }
        return $content === '' ? $tag : $tag->content($content);
    }

    /**
     * Generates a {@see Address} tag.
     *
     * @param string|Stringable $content Tag content.
     * @param array $attributes The tag attributes in terms of name-value pairs.
     */
    public static function address(string|Stringable $content = '', array $attributes = []): Address
    {
        $tag = Address::tag();
        if (!empty($attributes)) {
            $tag = $tag->attributes($attributes);
        }
        return $content === '' ? $tag : $tag->content($content);
    }

    /**
     * Renders the HTML tag attributes.
     *
     * Attributes whose values are of boolean type will be treated as
     * [boolean attributes](https://www.w3.org/TR/html5/infrastructure.html#boolean-attributes).
     *
     * Attributes whose values are null will not be rendered. The values of attributes will be HTML-encoded using
     * {@see encodeAttribute()}.
     *
     * The "data" attribute is specially handled when it is receiving an array value. In this case, the array will be
     * "expanded" and a list data attributes will be rendered. For example, if `'data' => ['id' => 1, 'name' => 'yii']`
     * then this will be rendered `data-id="1" data-name="yii"`.
     *
     * Additionally, `'data' => ['params' => ['id' => 1, 'name' => 'yii'], 'status' => 'ok']` will be rendered as:
     * `data-params='{"id":1,"name":"yii"}' data-status="ok"`.
     *
     * @param array $attributes Attributes to be rendered. The attribute values will be HTML-encoded using
     * {@see encodeAttribute()}.
     *
     * @throws JsonException
     *
     * @return string The rendering result. If the attributes are not empty, they will be rendered into a string
     * with a leading white space (so that it can be directly appended to the tag name in a tag). If there is no
     * attribute, an empty string will be returned.
     */
    public static function renderTagAttributes(array $attributes): string
    {
        if (count($attributes) > 1) {
            $sorted = [];
            foreach (self::ATTRIBUTE_ORDER as $name) {
                if (isset($attributes[$name])) {
                    $sorted[$name] = $attributes[$name];
                }
            }
            $attributes = array_merge($sorted, $attributes);
        }

        $html = '';
        /**
         * @var string $name
         */
        foreach ($attributes as $name => $value) {
            if (is_bool($value)) {
                if ($value) {
                    $html .= self::renderAttribute($name);
                }
            } elseif (is_array($value)) {
                if (in_array($name, self::DATA_ATTRIBUTES, true)) {
                    /** @psalm-var array<array-key, array|string|\Stringable|null> $value */
                    foreach ($value as $n => $v) {
                        $html .= is_array($v)
                            ? self::renderAttribute($name . '-' . $n, Json::htmlEncode($v), '\'')
                            : self::renderAttribute($name . '-' . $n, self::encodeAttribute($v));
                    }
                } elseif ($name === 'class') {
                    /** @var string[] $value */
                    if (empty($value)) {
                        continue;
                    }
                    $html .= self::renderAttribute($name, self::encodeAttribute(implode(' ', $value)));
                } elseif ($name === 'style') {
                    /** @psalm-var array<string,string> $value */
                    if (empty($value)) {
                        continue;
                    }
                    $html .= self::renderAttribute($name, self::encodeAttribute(self::cssStyleFromArray($value)));
                } else {
                    $html .= self::renderAttribute($name, Json::htmlEncode($value), '\'');
                }
            } elseif ($value !== null) {
                $html .= self::renderAttribute($name, self::encodeAttribute($value));
            }
        }

        return $html;
    }

    /**
     * Adds a CSS class (or several classes) to the specified options.
     *
     * If the CSS class is already in the options, it will not be added again. If class specification at given options
     * is an array, and some class placed there with the named (string) key, overriding of such key will have no
     * effect. For example:
     *
     * ```php
     * $options = ['class' => ['persistent' => 'initial']];
     *
     * // ['class' => ['persistent' => 'initial']];
     * Html::addCssClass($options, ['persistent' => 'override']);
     * ```
     *
     * @see removeCssClass()
     *
     * @param array $options The options to be modified.
     * @param null[]|string|string[]|null $class The CSS class(es) to be added. Null values will be ignored.
     *
     * @psalm-param string|array<array-key,string|null> $class
     */
    public static function addCssClass(array &$options, string|array|null $class): void
    {
        if ($class === null) {

The condition $class === null is always false.

            return;
        }
        if (is_array($class)) {

The condition is_array($class) is always true.

            $class = array_filter($class, static fn (mixed $c): bool => $c !== null);
            if (empty($class)) {
                return;
            }
        }

        if (isset($options['class'])) {
            if (is_array($options['class'])) {
                /** @psalm-var string[] $options['class'] */
                $options['class'] = self::mergeCssClasses($options['class'], (array) $class);
            } else {
                /** @psalm-var string $options['class'] */
                $classes = preg_split('/\s+/', $options['class'], -1, PREG_SPLIT_NO_EMPTY);
                $classes = self::mergeCssClasses($classes, (array) $class);
                $options['class'] = is_array($class) ? $classes : implode(' ', $classes);

The condition is_array($class) is always true.

            }
        } else {
            $options['class'] = $class;
        }
    }

    /**
     * Removes a CSS class from the specified options.
     *
     * @see addCssClass()
     *
     * @param array $options The options to be modified.
     * @param string|string[] $class The CSS class(es) to be removed.
     */
    public static function removeCssClass(array &$options, string|array $class): void
    {
        if (isset($options['class'])) {
            if (is_array($options['class'])) {
                $classes = array_diff($options['class'], (array) $class);
                if (empty($classes)) {
                    unset($options['class']);
                } else {
                    $options['class'] = $classes;
                }
            } else {
                /** @var string[] */
                $classes = preg_split('/\s+/', (string) $options['class'], -1, PREG_SPLIT_NO_EMPTY);
                $classes = array_diff($classes, (array) $class);
                if (empty($classes)) {
                    unset($options['class']);
                } else {
                    $options['class'] = implode(' ', $classes);
                }
            }
        }
    }

    /**
     * Merges already existing CSS classes with new one.
     *
     * This method provides the priority for named existing classes over additional.
     *
     * @param string[] $existingClasses Already existing CSS classes.
     * @param null[]|string[] $additionalClasses CSS classes to be added.
     *
     * @return string[] The merge result.
     *
     * @psalm-param array<array-key,string> $additionalClasses
     */
    private static function mergeCssClasses(array $existingClasses, array $additionalClasses): array
    {
        foreach ($additionalClasses as $key => $class) {
            if (is_int($key) && !in_array($class, $existingClasses, true)) {
                $existingClasses[] = $class;
            } elseif (!isset($existingClasses[$key])) {
                $existingClasses[$key] = $class;
            }
        }

        return array_unique($existingClasses);
    }

    /**
     * Adds the specified CSS styles to the HTML options.
     *
     * If the options already contain a `style` element, the new style will be merged
     * with the existing one. If a CSS property exists in both the new and the old styles,
     * the old one may be overwritten if `$overwrite` is true.
     *
     * For example,
     *
     * ```php
     * Html::addCssStyle($options, 'width: 100px; height: 200px');
     * ```
     *
     * @see removeCssStyle()
     *
     * @param array $options The HTML options to be modified.
     * @param array<string, string>|string $style The new style string (e.g. `'width: 100px; height: 200px'`) or array
     * (e.g. `['width' => '100px', 'height' => '200px']`).
     * @param bool $overwrite Whether to overwrite existing CSS properties if the new style contain them too.
     */
    public static function addCssStyle(array &$options, array|string $style, bool $overwrite = true): void
    {
        if (!empty($options['style'])) {
            /** @psalm-var array<string,string>|string $options['style'] */
            $oldStyle = is_array($options['style']) ? $options['style'] : self::cssStyleToArray($options['style']);
            $newStyle = is_array($style) ? $style : self::cssStyleToArray($style);

The condition is_array($style) is always true.

            if (!$overwrite) {
                foreach ($newStyle as $property => $_value) {
                    if (isset($oldStyle[$property])) {
                        unset($newStyle[$property]);
                    }
                }
            }
            $style = array_merge($oldStyle, $newStyle);
        }
        $options['style'] = is_array($style) ? self::cssStyleFromArray($style) : $style;

The condition is_array($style) is always true.

    }

    /**
     * Removes the specified CSS styles from the HTML options.
     *
     * For example,
     *
     * ```php
     * Html::removeCssStyle($options, ['width', 'height']);
     * ```
     *
     * @see addCssStyle()
     *
     * @param array $options The HTML options to be modified.
     * @param string|string[] $properties The CSS properties to be removed. You may use a string if you are removing a
     * single property.
     */
    public static function removeCssStyle(array &$options, string|array $properties): void
    {
        if (!empty($options['style'])) {
            /** @psalm-var array<string,string>|string $options['style'] */
            $style = is_array($options['style']) ? $options['style'] : self::cssStyleToArray($options['style']);
            foreach ((array) $properties as $property) {
                unset($style[$property]);
            }
            $options['style'] = self::cssStyleFromArray($style);
        }
    }

    /**
     * Converts a CSS style array into a string representation.
     *
     * For example,
     *
     * ```php
     * // width: 100px; height: 200px;
     * Html::cssStyleFromArray(['width' => '100px', 'height' => '200px']);
     * ```
     *
     * @see cssStyleToArray()
     *
     * @param array<string, string> $style The CSS style array. The array keys are the CSS property names,
     * and the array values are the corresponding CSS property values.
     *
     * @return string|null The CSS style string. If the CSS style is empty, a null will be returned.
     */
    public static function cssStyleFromArray(array $style): ?string
    {
        $result = '';
        foreach ($style as $name => $value) {
            $result .= "$name: $value; ";
        }

        // Return null if empty to avoid rendering the "style" attribute.
        return $result === '' ? null : rtrim($result);
    }

    /**
     * Converts a CSS style string into an array representation.
     *
     * The array keys are the CSS property names, and the array values are the corresponding CSS property values.
     *
     * For example,
     *
     * ```php
     * // ['width' => '100px', 'height' => '200px']
     * Html::cssStyleToArray('width: 100px; height: 200px;');
     * ```
     *
     * @see cssStyleFromArray()
     *
     * @param string|\Stringable $style The CSS style string.
     *
     * @return array The array representation of the CSS style.
     * @psalm-return array<string, string>
     */
    public static function cssStyleToArray(string|Stringable $style): array
    {
        $result = [];
        foreach (explode(';', (string) $style) as $property) {
            $property = explode(':', $property);
            if (count($property) > 1) {
                $result[trim($property[0])] = trim($property[1]);
            }
        }

        return $result;
    }

    /**
     * Normalize PCRE regular expression to use in the "pattern" HTML attribute:
     *  - convert \x{FFFF} to \uFFFF;
     *  - remove flags and delimiters.
     *
     * For example:
     *
     * ```php
     * Html::normalizeRegexpPattern('/([a-z0-9-]+)/im'); // will return: ([a-z0-9-]+)
     * ```
     *
     * @link https://html.spec.whatwg.org/multipage/input.html#the-pattern-attribute
     *
     * @param string $regexp PCRE regular expression.
     * @param string|null $delimiter Regular expression delimiter.
     *
     * @throws InvalidArgumentException if incorrect regular expression or delimiter
     *
     * @return string Value for use in the "pattern" HTML attribute
     */
    public static function normalizeRegexpPattern(string $regexp, ?string $delimiter = null): string
    {
        if (strlen($regexp) < 2) {
            throw new InvalidArgumentException('Incorrect regular expression.');
        }

        $pattern = preg_replace('/\\\\x{?([0-9a-fA-F]+)}?/', '\u$1', $regexp);

        if ($delimiter === null) {
            $delimiter = substr($pattern, 0, 1);
        } elseif (strlen($delimiter) !== 1) {
            throw new InvalidArgumentException('Incorrect delimiter.');
        }

        $endPosition = strrpos($pattern, $delimiter, 1);
        if ($endPosition === false) {
            throw new InvalidArgumentException('Incorrect regular expression.');
        }

        return substr($pattern, 1, $endPosition - 1);
    }

    public static function getArrayableName(string $name): string
    {
        return !str_ends_with($name, '[]') ? $name . '[]' : $name;
    }

    public static function getNonArrayableName(string $name): string
    {
        return str_ends_with($name, '[]') ? substr($name, 0, -2) : $name;
    }

    /**
     * Render attribute in HTML tag.
     *
     * @link https://html.spec.whatwg.org/#a-quick-introduction-to-html
     */
    private static function renderAttribute(string $name, string $encodedValue = '', string $quote = '"'): string
    {
        // The value, along with the "=" character, can be omitted altogether if the value is the empty string.
        if ($encodedValue === '') {
            return ' ' . $name;
        }

        return ' ' . $name . '=' . $quote . $encodedValue . $quote;
    }
}