diff --git a/Zend/tests/markup_operand_position_bc.phpt b/Zend/tests/markup_operand_position_bc.phpt
new file mode 100644
index 000000000000..1f42c284ff9c
--- /dev/null
+++ b/Zend/tests/markup_operand_position_bc.phpt
@@ -0,0 +1,131 @@
+--TEST--
+Native markup: bare "<" after operand-ending tokens stays a comparison (no-space BC)
+--FILE--
+<?php
+// Postfix ++/-- end an operand: "<" is a comparison, not markup.
+$i = 0; $n = 5;
+$a = [1, 2, 3];
+var_dump($i++<PHP_INT_MAX);
+var_dump($i--<$n);
+$count = 0;
+while ($count++<count($a)) {}
+var_dump($count);
+
+// The `class` keyword in ::class ends an operand too.
+const FOO = "zzz";
+var_dump(\stdClass::class<FOO);
+var_dump(self_name()<FOO);
+function self_name(): string { return "aaa"; }
+
+// Plain constants / qualified names end an operand.
+var_dump(FOO<"zzzz");
+var_dump(PHP_INT_MAX<FOO);
+
+// `]` (array dereference) and `}` end an operand.
+var_dump($a[0]<FOO);
+var_dump(match(true) { default => 1 }<FOO);
+
+// A closing heredoc label ends an operand.
+var_dump(<<<EOT
+aaa
+EOT<FOO);
+
+// Interpolated string closing quote ends an operand.
+$s = "aa";
+var_dump("a$s"<FOO);
+
+// `static` is a complete operand (instanceof static), never markup.
+class Base { public function check(object $o): bool { return $o instanceof static<FOO; } }
+var_dump((new Base)->check(new Base));
+
+// Bare `exit` is an expression operand; "<" after it is a comparison.
+// (Only reached when the left side is falsy-compared, so guard it.)
+function never_exit(): bool { return false && exit<FOO; }
+var_dump(never_exit());
+
+// The legacy `<>` operator is untouched in infix (operator) position.
+var_dump($a[0]<>2);
+
+// Plain variables, literals, and `)` end an operand too, with or without spaces.
+$lhs = 1; $rhs = 2;
+var_dump($lhs < $rhs);
+var_dump($lhs<$rhs);
+var_dump(3 < 4);
+var_dump(($lhs) < $rhs);
+
+// Other "<"-led operators are unchanged: spaceship, less-or-equal, shifts.
+var_dump($lhs <=> $rhs);
+var_dump($lhs <= $rhs);
+var_dump(1 << 4);
+var_dump(64 >> 2);
+
+// A heredoc body containing "<" stays literal text, not markup.
+echo <<<EOT
+literal <not-markup> text
+EOT, "\n";
+
+// Error suppression with "@" still works before an expression.
+$sup = []; var_dump(@$sup['missing']);
+
+// Bare `yield` is a complete operand: `<` and `<>` after it stay comparisons
+// ((yield) != 5, (yield) < FOO), with or without spaces. Yielding markup
+// therefore needs parentheses: `yield (<div/>)`.
+function gen_ne() { var_dump(yield <> 5); }
+$g = gen_ne(); $g->current(); $g->send(7);
+function gen_lt() { var_dump(yield < FOO); }
+$g = gen_lt(); $g->current(); $g->send("aaa");
+function gen_lt_nospace() { $r = yield<FOO; var_dump($r); }
+$g = gen_lt_nospace(); $g->current(); $g->send("aaa");
+
+// Inverse direction: in operand position (after `=`, `(`, `,`, `=>`, `return`,
+// and parenthesized after `yield`) a "<tag" IS markup. Compile-time
+// classification only - never executed, so this parses even in builds where
+// the Html\ runtime classes are unavailable.
+function never_runs() {
+    $x = <div/>;
+    take(<p>hi</p>, <br/>);
+    $f = fn() => <span>a</span>;
+    yield (<li>item</li>);
+    return <em>done</em>;
+}
+
+// Dynamic tags: "<$tag" and "<{expr}" in operand position are markup
+// ("$i--<$n" above is the operator-position inverse, still a comparison).
+function never_runs_dynamic() {
+    $tag = 'div';
+    $x = <$tag class="a">hi</$tag>;
+    $y = <{$tag . 'x'}>hi</>;
+    take(<{pick()}/>);
+    return <$tag/>;
+}
+echo "parsed\n";
+?>
+--EXPECT--
+bool(true)
+bool(true)
+int(4)
+bool(true)
+bool(true)
+bool(true)
+bool(true)
+bool(true)
+bool(true)
+bool(true)
+bool(true)
+bool(false)
+bool(false)
+bool(true)
+bool(true)
+bool(true)
+bool(true)
+bool(true)
+int(-1)
+bool(true)
+int(16)
+int(16)
+literal <not-markup> text
+NULL
+bool(true)
+bool(true)
+bool(true)
+parsed
diff --git a/Zend/zend_globals.h b/Zend/zend_globals.h
index 61499c0cc23d..062cf62f3a9c 100644
--- a/Zend/zend_globals.h
+++ b/Zend/zend_globals.h
@@ -402,6 +402,11 @@ struct _zend_php_scanner_globals {
 	/* initial string length after scanning to first variable */
 	int scanned_string_len;
 
+	/* Last significant token returned, used to decide whether a bare "<" in
+	 * ST_IN_SCRIPTING is in operand position (begins native markup) or operator
+	 * position (a comparison). See zend_language_scanner.l. */
+	int last_token;
+
 	/* hooks */
 	void (*on_event)(
 		zend_php_scanner_event event, int token, int line,
diff --git a/Zend/zend_language_parser.y b/Zend/zend_language_parser.y
index b4dda00404ea..325dae1c0fca 100644
--- a/Zend/zend_language_parser.y
+++ b/Zend/zend_language_parser.y
@@ -26,6 +26,7 @@
 #include "zend_constants.h"
 #include "zend_language_scanner.h"
 #include "zend_exceptions.h"
+#include "zend_markup.h"
 
 #define YYSIZE_T size_t
 #define yytnamerr zend_yytnamerr
@@ -250,6 +251,20 @@ static YYSIZE_T zend_yytnamerr(char*, const char*);
 /* Token used to force a parse error from the lexer */
 %token T_ERROR
 
+/* Native markup tokens. Declared last so they append to the token enum:
+ * inserting them mid-list would renumber every later token (T_INLINE_HTML
+ * onward), breaking code that hardcodes token integers. */
+%token <ast> T_MARKUP_NAME "markup tag name"
+%token <ast> T_MARKUP_TEXT "markup text"
+%token <ast> T_MARKUP_ATTR_VALUE "markup attribute value"
+%token <ast> T_MARKUP_COMMENT "markup comment"
+%token T_MARKUP_OPEN "markup tag start"
+%token T_MARKUP_CLOSE_OPEN "markup closing tag start"
+%token T_MARKUP_TAG_END "markup tag end"
+%token T_MARKUP_SELF_CLOSE "markup self-close"
+%token T_MARKUP_INTERP_START "markup interpolation start"
+%token <ast> T_MARKUP_DOCTYPE "markup doctype"
+
 %type <ast> top_statement namespace_name name statement function_declaration_statement
 %type <ast> class_declaration_statement trait_declaration_statement legacy_namespace_name
 %type <ast> interface_declaration_statement interface_extends_list
@@ -283,6 +298,8 @@ static YYSIZE_T zend_yytnamerr(char*, const char*);
 %type <ast> attributed_statement attributed_top_statement attributed_class_statement attributed_parameter
 %type <ast> attribute_decl attribute attributes attribute_group namespace_declaration_name
 %type <ast> match match_arm_list non_empty_match_arm_list match_arm match_arm_cond_list
+%type <ast> markup_element markup_children markup_child
+%type <ast> markup_attributes markup_attribute
 %type <ast> enum_declaration_statement enum_backing_type enum_case enum_case_expr
 %type <ast> function_name non_empty_member_modifiers
 %type <ast> property_hook property_hook_list optional_property_hook_list hooked_property property_hook_body
@@ -1249,9 +1266,58 @@ new_non_dereferenceable:
 			{ $$ = zend_ast_create(ZEND_AST_NEW, $2, zend_ast_create_list(0, ZEND_AST_ARG_LIST)); }
 ;
 
+markup_element:
+		T_MARKUP_OPEN T_MARKUP_NAME markup_attributes T_MARKUP_TAG_END markup_children T_MARKUP_CLOSE_OPEN T_MARKUP_NAME T_MARKUP_TAG_END
+			{ $$ = zend_ast_create_markup_checked($2, $3, $5, $7, false); if (!$$) { YYERROR; } }
+	|	T_MARKUP_OPEN T_MARKUP_NAME markup_attributes T_MARKUP_SELF_CLOSE
+			{ $$ = zend_ast_create_markup_element($2, $3, NULL); if (!$$) { YYERROR; } }
+	|	T_MARKUP_OPEN T_MARKUP_TAG_END markup_children T_MARKUP_CLOSE_OPEN T_MARKUP_TAG_END
+			{ $$ = zend_ast_create_markup_element(NULL, NULL, $3); if (!$$) { YYERROR; } }
+	|	T_MARKUP_OPEN T_VARIABLE markup_attributes T_MARKUP_TAG_END markup_children T_MARKUP_CLOSE_OPEN T_VARIABLE T_MARKUP_TAG_END
+			{ $$ = zend_ast_create_markup_checked($2, $3, $5, $7, true); if (!$$) { YYERROR; } }
+	|	T_MARKUP_OPEN T_VARIABLE markup_attributes T_MARKUP_SELF_CLOSE
+			{ $$ = zend_ast_create_markup_dynamic($2, $3, NULL); }
+	|	T_MARKUP_OPEN T_MARKUP_INTERP_START expr '}' markup_attributes T_MARKUP_TAG_END markup_children T_MARKUP_CLOSE_OPEN T_MARKUP_TAG_END
+			{ $$ = zend_ast_create_markup_dynamic_expr($3, $5, $7); }
+	|	T_MARKUP_OPEN T_MARKUP_INTERP_START expr '}' markup_attributes T_MARKUP_SELF_CLOSE
+			{ $$ = zend_ast_create_markup_dynamic_expr($3, $5, NULL); }
+;
+
+markup_attributes:
+		%empty								{ $$ = zend_ast_create_list(0, ZEND_AST_ARRAY); }
+	|	markup_attributes markup_attribute	{ $$ = zend_ast_list_add($1, $2); }
+;
+
+markup_attribute:
+		T_MARKUP_NAME '=' T_MARKUP_ATTR_VALUE
+			{ $$ = zend_ast_create(ZEND_AST_ARRAY_ELEM, $3, $1); }
+	|	T_MARKUP_NAME '=' T_MARKUP_INTERP_START expr '}'
+			{ $$ = zend_ast_create(ZEND_AST_ARRAY_ELEM, $4, $1); }
+	|	T_MARKUP_NAME
+			{ zval t; ZVAL_TRUE(&t); $$ = zend_ast_create(ZEND_AST_ARRAY_ELEM, zend_ast_create_zval(&t), $1); }
+	|	T_MARKUP_INTERP_START T_ELLIPSIS expr '}'
+			{ $$ = zend_ast_create(ZEND_AST_UNPACK, $3); }
+;
+
+markup_children:
+		%empty							{ $$ = zend_ast_create_list(0, ZEND_AST_ARRAY); }
+	|	markup_children markup_child	{ $$ = zend_ast_list_add($1, $2); }
+;
+
+markup_child:
+		T_MARKUP_TEXT					{ $$ = zend_ast_create(ZEND_AST_ARRAY_ELEM, $1, NULL); }
+	|	T_MARKUP_COMMENT				{ $$ = zend_ast_create(ZEND_AST_ARRAY_ELEM, zend_ast_create_markup_raw($1), NULL); }
+	|	T_MARKUP_DOCTYPE				{ $$ = zend_ast_create(ZEND_AST_ARRAY_ELEM, zend_ast_create_markup_raw($1), NULL); }
+	|	T_MARKUP_INTERP_START expr '}'	{ $$ = zend_ast_create(ZEND_AST_ARRAY_ELEM, $2, NULL); }
+	|	T_MARKUP_INTERP_START '}'		{ zval n; ZVAL_NULL(&n); $$ = zend_ast_create(ZEND_AST_ARRAY_ELEM, zend_ast_create_zval(&n), NULL); }
+	|	markup_element					{ $$ = zend_ast_create(ZEND_AST_ARRAY_ELEM, $1, NULL); }
+;
+
 expr:
 		variable
 			{ $$ = $1; }
+	|	markup_element
+			{ $$ = $1; }
 	|	T_LIST '(' array_pair_list ')' '=' expr
 			{ $3->attr = ZEND_ARRAY_SYNTAX_LIST; $$ = zend_ast_create(ZEND_AST_ASSIGN, $3, $6); }
 	|	'[' array_pair_list ']' '=' expr
diff --git a/Zend/zend_language_scanner.h b/Zend/zend_language_scanner.h
index e502d91411b5..1415e2fa991d 100644
--- a/Zend/zend_language_scanner.h
+++ b/Zend/zend_language_scanner.h
@@ -30,6 +30,7 @@ typedef struct _zend_lex_state {
 	unsigned char *yy_marker;
 	unsigned char *yy_limit;
 	int yy_state;
+	int last_token; /* operand-vs-operator position for native markup */
 	zend_stack state_stack;
 	zend_ptr_stack heredoc_label_stack;
 	zend_stack nest_location_stack; /* for syntax error reporting */
diff --git a/Zend/zend_language_scanner.l b/Zend/zend_language_scanner.l
index 07f2d44cb5c6..0bbaaedf254a 100644
--- a/Zend/zend_language_scanner.l
+++ b/Zend/zend_language_scanner.l
@@ -46,6 +46,7 @@
 #include "zend_strtod.h"
 #include "zend_exceptions.h"
 #include "zend_virtual_cwd.h"
+#include "zend_markup.h"
 
 #define YYCTYPE   unsigned char
 #define YYFILL(n) { if ((YYCURSOR + n) >= (YYLIMIT + ZEND_MMAP_AHEAD)) { return 0; } }
@@ -194,6 +195,7 @@ void startup_scanner(void)
 	zend_stack_init(&SCNG(nest_location_stack), sizeof(zend_nest_location));
 	zend_ptr_stack_init(&SCNG(heredoc_label_stack));
 	SCNG(heredoc_scan_ahead) = 0;
+	SCNG(last_token) = 0;
 }
 
 static void heredoc_label_dtor(zend_heredoc_label *heredoc_label) {
@@ -233,6 +235,7 @@ ZEND_API void zend_save_lexical_state(zend_lex_state *lex_state)
 
 	lex_state->in = SCNG(yy_in);
 	lex_state->yy_state = YYSTATE;
+	lex_state->last_token = SCNG(last_token);
 	lex_state->filename = CG(compiled_filename);
 	lex_state->lineno = CG(zend_lineno);
 	CG(compiled_filename) = NULL;
@@ -273,6 +276,7 @@ ZEND_API void zend_restore_lexical_state(zend_lex_state *lex_state)
 
 	SCNG(yy_in) = lex_state->in;
 	YYSETCONDITION(lex_state->yy_state);
+	SCNG(last_token) = lex_state->last_token;
 	CG(zend_lineno) = lex_state->lineno;
 	zend_restore_compiled_filename(lex_state->filename);
 
@@ -543,6 +547,7 @@ ZEND_API zend_result open_file_for_scanning(zend_file_handle *file_handle)
 	/* Reset the scanner for scanning the new file */
 	SCNG(yy_in) = file_handle;
 	SCNG(yy_start) = NULL;
+	SCNG(last_token) = 0;
 
 	if (size != (size_t)-1) {
 		if (CG(multibyte)) {
@@ -744,6 +749,7 @@ ZEND_API void zend_prepare_string_for_scanning(zval *str, zend_string *filename)
 
 	SCNG(yy_in) = NULL;
 	SCNG(yy_start) = NULL;
+	SCNG(last_token) = 0;
 
 	buf = Z_STRVAL_P(str);
 	size = old_len;
@@ -1357,6 +1363,119 @@ static zend_result check_nesting_at_end(void)
 		} \
 	} while (0)
 
+/* Native markup (RFC: Native Markup Expressions). A bare "<" in ST_IN_SCRIPTING
+ * begins a markup expression only in *operand* position (where a value, not an
+ * operator, is expected), decided from the last significant token. The decision
+ * is an allowlist that FAILS CLOSED: markup begins only after a token known to
+ * expect an operand - a position where an infix "<" cannot legally appear
+ * today - and after every other token "<" keeps its existing meaning. So a
+ * token missing from this list can never change what existing code means; the
+ * worst a gap can do is make markup unavailable in that one context (a loud
+ * feature-side parse error, fixed by parenthesizing - or by adding the token
+ * here). Contributors adding a new operator or expression-introducing keyword
+ * should add it to this list so markup can follow it directly.
+ *
+ * Deliberate exclusions, each because "<" after it is (or may be) valid PHP:
+ *   - "}" ends match/interpolation values, so it must stay a comparison; the
+ *     cost is that markup as an expression statement directly after a block -
+ *     `if ($c) { ... } <p>hi</p>;` - fails to parse. Assign or echo it instead.
+ *   - bare `yield` is a complete operand (`yield < LIM`, `yield <> 5` are
+ *     valid PHP), so yielding markup needs parentheses: `yield (<div/>)`.
+ *     (`yield from` requires an operand, so markup after it just works.)
+ *   - ")" would enable `if ($c) <p>hi</p>;` but ends grouped operands
+ *     (`($a+$b) < $c`); parenthesized markup `(<p/>)` already works. */
+static bool zend_markup_operand_position(void)
+{
+	switch (SCNG(last_token)) {
+		/* nothing scanned yet (an eval'd string can begin with an expression) */
+		case 0:
+		/* statement starts and separators */
+		case T_OPEN_TAG:
+		case T_OPEN_TAG_WITH_ECHO:
+		case ';':
+		case '{':
+		case ':': /* alternative syntax, case/default labels, ternary else */
+		/* grouping and lists */
+		case '(':
+		case '[':
+		case ',':
+		/* assignment */
+		case '=':
+		case T_PLUS_EQUAL:
+		case T_MINUS_EQUAL:
+		case T_MUL_EQUAL:
+		case T_DIV_EQUAL:
+		case T_MOD_EQUAL:
+		case T_CONCAT_EQUAL:
+		case T_AND_EQUAL:
+		case T_OR_EQUAL:
+		case T_XOR_EQUAL:
+		case T_SL_EQUAL:
+		case T_SR_EQUAL:
+		case T_POW_EQUAL:
+		case T_COALESCE_EQUAL:
+		case T_DOUBLE_ARROW:
+		/* unary and binary operators */
+		case '+':
+		case '-':
+		case '*':
+		case '/':
+		case '%':
+		case '.':
+		case '<':
+		case '>':
+		case '|':
+		case '^':
+		case '?':
+		case '!':
+		case '~':
+		case '@':
+		case T_AMPERSAND_FOLLOWED_BY_VAR_OR_VARARG:
+		case T_AMPERSAND_NOT_FOLLOWED_BY_VAR_OR_VARARG:
+		case T_SL:
+		case T_SR:
+		case T_POW:
+		case T_COALESCE:
+		case T_BOOLEAN_AND:
+		case T_BOOLEAN_OR:
+		case T_LOGICAL_AND:
+		case T_LOGICAL_OR:
+		case T_LOGICAL_XOR:
+		case T_IS_EQUAL:
+		case T_IS_NOT_EQUAL:
+		case T_IS_IDENTICAL:
+		case T_IS_NOT_IDENTICAL:
+		case T_IS_SMALLER_OR_EQUAL:
+		case T_IS_GREATER_OR_EQUAL:
+		case T_SPACESHIP:
+		case T_PIPE:
+		/* keywords that introduce an expression */
+		case T_RETURN:
+		case T_ECHO:
+		case T_PRINT:
+		case T_THROW:
+		case T_CLONE:
+		case T_CASE:
+		case T_YIELD_FROM:
+		case T_ELLIPSIS:
+		/* casts */
+		case T_INT_CAST:
+		case T_DOUBLE_CAST:
+		case T_STRING_CAST:
+		case T_ARRAY_CAST:
+		case T_OBJECT_CAST:
+		case T_BOOL_CAST:
+		case T_UNSET_CAST:
+		case T_VOID_CAST:
+		/* markup interpolation: `{` in markup content, child or attribute
+		 * position, restarts expression context (nested markup must lex) */
+		case T_MARKUP_INTERP_START:
+			return true;
+		default:
+			return false;
+	}
+}
+
 int ZEND_FASTCALL lex_scan(zval *zendlval, zend_parser_stack_elem *elem)
 {
 int token;
@@ -1376,6 +1495,9 @@ HNUM	"0x"[0-9a-fA-F]+(_[0-9a-fA-F]+)*
 BNUM	"0b"[01]+(_[01]+)*
 ONUM	"0o"[0-7]+(_[0-7]+)*
 LABEL	[a-zA-Z_\x80-\xff][a-zA-Z0-9_\x80-\xff]*
+/* Native markup: one segment of a tag or attribute name. Dots,
+ * colons and hyphens are allowed inside (<my-widget>, wire:poll.1s). */
+MARKUP_LABEL [a-zA-Z][a-zA-Z0-9_.:-]*
 WHITESPACE [ \n\r\t]+
 TABS_AND_SPACES [ \t]*
 TOKENS [;:,.|^&+-/*=%!~$<>?@]
@@ -1842,7 +1964,7 @@ OPTIONAL_WHITESPACE_OR_COMMENTS ({WHITESPACE}|{MULTI_LINE_COMMENT}|{SINGLE_LINE_
 	RETURN_TOKEN(T_IS_EQUAL);
 }
 
-<ST_IN_SCRIPTING>"!="|"<>" {
+<ST_IN_SCRIPTING>"!=" {
 	RETURN_TOKEN(T_IS_NOT_EQUAL);
 }
 
@@ -1977,6 +2099,199 @@ OPTIONAL_WHITESPACE_OR_COMMENTS ({WHITESPACE}|{MULTI_LINE_COMMENT}|{SINGLE_LINE_
 }
 
 
+/* Native markup (RFC: Native Markup Expressions). In operand position, "<"
+ * followed by a tag opener begins markup: "<tag" / "<\Ns\Tag" (element or
+ * component), "<>" (fragment), "<$var" / "<{expr}" (dynamic tags). In operator
+ * position everything keeps its existing meaning: "<" a comparison ("$a <$b",
+ * "$a < \Foo::BAR") and "<>" the legacy not-equal alias. The opener set here
+ * is mirrored by ST_MARKUP_CONTENT's nested-tag rule below. */
+<ST_IN_SCRIPTING>"<"("\\"?[a-zA-Z]|[>${]) {
+	if (zend_markup_operand_position()) {
+		yyless(1);
+		yy_push_state(ST_MARKUP_TAG);
+		RETURN_TOKEN(T_MARKUP_OPEN);
+	}
+	if (yytext[1] == '>') {
+		RETURN_TOKEN(T_IS_NOT_EQUAL);
+	}
+	yyless(1);
+	RETURN_TOKEN('<');
+}
+
+<ST_MARKUP_TAG,ST_MARKUP_CLOSE>{WHITESPACE} {
+	/* Count newlines and emit T_WHITESPACE in tokenizer mode, like ordinary
+	 * whitespace (a bare restart would freeze line numbers and swallow the
+	 * whitespace from token_get_all). */
+	goto return_whitespace;
+}
+
+<ST_MARKUP_TAG,ST_MARKUP_CLOSE>"\\"?{MARKUP_LABEL}("\\"{MARKUP_LABEL})* {
+	/* A tag name, optionally namespace-qualified (<App\Card/>) or fully
+	 * qualified (<\App\Card/>). A name containing "\" always dispatches as a
+	 * component (see zend_markup_name_is_component in Zend/zend_markup.c). */
+	RETURN_TOKEN_WITH_STR(T_MARKUP_NAME, 0);
+}
+
+<ST_MARKUP_TAG>[:@]{MARKUP_LABEL} {
+	/* An attribute name with a ":" or "@" shorthand prefix (Vue/Alpine:
+	 * :class, @click). Attribute position only: this can never lex as a tag
+	 * name, because every markup-open rule requires a letter, "\", "$", "{"
+	 * or ">" after "<", and ST_MARKUP_CLOSE is excluded here. */
+	RETURN_TOKEN_WITH_STR(T_MARKUP_NAME, 0);
+}
+
+<ST_MARKUP_TAG,ST_MARKUP_CLOSE>"$"{LABEL} {
+	/* A dynamic tag name (<$tag>…</$tag>): an ordinary variable whose runtime
+	 * value decides element vs component (see Html\render_dynamic). */
+	RETURN_TOKEN_WITH_STR(T_VARIABLE, 1);
+}
+
+<ST_MARKUP_TAG>"=" {
+	RETURN_TOKEN('=');
+}
+
+<ST_MARKUP_TAG>"\"" [^"]* "\"" {
+	/* Literal double-quoted attribute value (escaped at render time). The
+	 * quotes stay part of the token text (yyleng untouched) so token_get_all
+	 * round-trips; only the zval payload is the unquoted interior, with
+	 * character references decoded for the compiler. */
+	HANDLE_NEWLINES(yytext, yyleng);
+	zend_copy_value(zendlval, yytext + 1, yyleng - 2);
+	if (PARSER_MODE() && !SCNG(on_event) && Z_TYPE_P(zendlval) == IS_STRING) {
+		ZVAL_STR(zendlval, zend_markup_decode_entities(Z_STR_P(zendlval)));
+	}
+	RETURN_TOKEN_WITH_VAL(T_MARKUP_ATTR_VALUE);
+}
+
+<ST_MARKUP_TAG>"{" {
+	yy_push_state(ST_IN_SCRIPTING);
+	enter_nesting('{');
+	RETURN_TOKEN(T_MARKUP_INTERP_START);
+}
+
+<ST_MARKUP_TAG>"/>" {
+	yy_pop_state();
+	RETURN_TOKEN(T_MARKUP_SELF_CLOSE);
+}
+
+<ST_MARKUP_TAG>">" {
+	BEGIN(ST_MARKUP_CONTENT);
+	RETURN_TOKEN(T_MARKUP_TAG_END);
+}
+
+<ST_MARKUP_CLOSE>">" {
+	yy_pop_state();
+	RETURN_TOKEN(T_MARKUP_TAG_END);
+}
+
+<ST_MARKUP_TAG,ST_MARKUP_CLOSE>{ANY_CHAR} {
+	if (YYCURSOR > YYLIMIT) {
+		RETURN_END_TOKEN;
+	}
+	RETURN_TOKEN(T_ERROR);
+}
+
+<ST_MARKUP_CONTENT>"<!--" {
+	/* An HTML comment, emitted verbatim. Scan to the closing "-->";
+	 * content is literal (no interpolation). */
+	while (YYCURSOR < YYLIMIT) {
+		if (YYCURSOR + 2 < YYLIMIT && YYCURSOR[0] == '-' && YYCURSOR[1] == '-' && YYCURSOR[2] == '>') {
+			YYCURSOR += 3;
+			yyleng = YYCURSOR - SCNG(yy_text);
+			HANDLE_NEWLINES(yytext, yyleng);
+			RETURN_TOKEN_WITH_STR(T_MARKUP_COMMENT, 0);
+		}
+		YYCURSOR++;
+	}
+	RETURN_TOKEN(T_ERROR);
+}
+
+<ST_MARKUP_CONTENT>"<!doctype" {
+	/* An HTML doctype, emitted verbatim like a comment. Matches
+	 * case-insensitively (--case-inverted); scan to the closing ">";
+	 * content is literal (no interpolation). */
+	while (YYCURSOR < YYLIMIT) {
+		if (*YYCURSOR == '>') {
+			YYCURSOR++;
+			yyleng = YYCURSOR - SCNG(yy_text);
+			HANDLE_NEWLINES(yytext, yyleng);
+			RETURN_TOKEN_WITH_STR(T_MARKUP_DOCTYPE, 0);
+		}
+		YYCURSOR++;
+	}
+	RETURN_TOKEN(T_ERROR);
+}
+
+<ST_MARKUP_CONTENT>"<!" {
+	/* Any other markup declaration. CDATA sections in particular cannot take
+	 * the scan-to-">" shortcut (they end at "]]>" and may contain ">"), so
+	 * reject with a targeted message rather than the generic stray-"<" one. */
+	if (PARSER_MODE()) {
+		zend_throw_exception(zend_ce_parse_error,
+			"Unsupported markup declaration; only <!-- --> comments and <!doctype> are supported", 0);
+	}
+	RETURN_TOKEN(T_ERROR);
+}
+
+<ST_MARKUP_CONTENT>"</" {
+	BEGIN(ST_MARKUP_CLOSE);
+	RETURN_TOKEN(T_MARKUP_CLOSE_OPEN);
+}
+
+<ST_MARKUP_CONTENT>"<"("\\"?[a-zA-Z]|[>${]) {
+	/* A nested tag ("<div", "<\App\Card", dynamic "<$tag" / "<{expr}",
+	 * fragment "<>") - the same opener set as the ST_IN_SCRIPTING rule, always
+	 * markup here (content is operand position by construction). "</",
+	 * "<!--" and "<!doctype" have their own rules above. */
+	yyless(1);
+	yy_push_state(ST_MARKUP_TAG);
+	RETURN_TOKEN(T_MARKUP_OPEN);
+}
+
+<ST_MARKUP_CONTENT>"<" {
+	/* A stray "<" in text - give a clear error rather than a bare syntax
+	 * error on T_ERROR. */
+	if (PARSER_MODE()) {
+		zend_throw_exception(zend_ce_parse_error,
+			"Unescaped \"<\" in markup text; write {'<'} for a literal less-than sign", 0);
+	}
+	RETURN_TOKEN(T_ERROR);
+}
+
+<ST_MARKUP_CONTENT>"{" {
+	yy_push_state(ST_IN_SCRIPTING);
+	enter_nesting('{');
+	RETURN_TOKEN(T_MARKUP_INTERP_START);
+}
+
+<ST_MARKUP_CONTENT>{ANY_CHAR} {
+	if (YYCURSOR > YYLIMIT) {
+		RETURN_END_TOKEN;
+	}
+	/* Accumulate a run of literal text up to the next "<" or "{". */
+	while (YYCURSOR < YYLIMIT) {
+		if (*YYCURSOR == '<' || *YYCURSOR == '{') {
+			break;
+		}
+		YYCURSOR++;
+	}
+	yyleng = YYCURSOR - SCNG(yy_text);
+	HANDLE_NEWLINES(yytext, yyleng);
+	/* Normalize whitespace for the compiler only; when collecting tokens
+	 * (token_get_all) emit the raw text so the source round-trips. */
+	if (PARSER_MODE() && !SCNG(on_event)) {
+		zend_string *normalized = zend_markup_normalize_text(yytext, yyleng);
+		if (ZSTR_LEN(normalized) == 0) {
+			zend_string_release(normalized);
+			goto restart;
+		}
+		ZVAL_STR(zendlval, zend_markup_decode_entities(normalized));
+		RETURN_TOKEN_WITH_VAL(T_MARKUP_TEXT);
+	}
+	RETURN_TOKEN_WITH_STR(T_MARKUP_TEXT, 0);
+}
+
+
 <ST_DOUBLE_QUOTES,ST_BACKQUOTE,ST_HEREDOC>"${" {
 	yy_push_state(ST_LOOKING_FOR_VARNAME);
 	enter_nesting('{');
@@ -3196,12 +3511,19 @@ emit_token_with_val:
 	}
 
 emit_token:
+	/* Track the last significant token for operand-vs-operator detection of a
+	 * bare "<" (native markup). Whitespace/comments are skipped in parser mode
+	 * but emitted in tokenizer mode, so ignore them here for a consistent view. */
+	if (token != T_WHITESPACE && token != T_COMMENT && token != T_DOC_COMMENT) {
+		SCNG(last_token) = token;
+	}
 	if (SCNG(on_event)) {
 		SCNG(on_event)(ON_TOKEN, token, start_line, yytext, yyleng, SCNG(on_event_context));
 	}
 	return token;
 
 emit_token_with_ident:
+	SCNG(last_token) = token;
 	if (PARSER_MODE()) {
 		elem->ident = SCNG(yy_text);
 	}
diff --git a/Zend/zend_markup.c b/Zend/zend_markup.c
new file mode 100644
index 000000000000..01f0014f6294
--- /dev/null
+++ b/Zend/zend_markup.c
@@ -0,0 +1,594 @@
+/*
+   +----------------------------------------------------------------------+
+   | Zend Engine                                                          |
+   +----------------------------------------------------------------------+
+   | Copyright © Zend Technologies Ltd., a subsidiary company of          |
+   |     Perforce Software, Inc., and Contributors.                       |
+   +----------------------------------------------------------------------+
+   | This source file is subject to the Modified BSD License that is      |
+   | bundled with this package in the file LICENSE, and is available      |
+   | through the World Wide Web at <https://www.php.net/license/>.        |
+   |                                                                      |
+   | SPDX-License-Identifier: BSD-3-Clause                                |
+   +----------------------------------------------------------------------+
+   | Author: Liam Hammett                                                 |
+   +----------------------------------------------------------------------+
+*/
+
+/* Native Markup Expressions compile-time support:
+ *
+ *   - text normalization and character-reference decoding, called by the
+ *     lexer (Zend/zend_language_scanner.l) on markup text and literal
+ *     attribute values;
+ *   - AST lowering, called by the grammar actions
+ *     (Zend/zend_language_parser.y) to turn markup elements into ordinary
+ *     `new \Html\Element(...)` / `\Html\render_component(...)` ASTs, so no
+ *     new AST node kinds or zend_compile.c support are needed.
+ *
+ * The lexing mechanics themselves (scanner states, operand-position
+ * detection) stay in the scanner; everything here is pure data-to-data. */
+
+#include "zend.h"
+#include "zend_ast.h"
+#include "zend_compile.h"
+#include "zend_exceptions.h"
+#include "zend_smart_str.h"
+#include "zend_markup.h"
+#include "zend_markup_entities.h"
+
+/* Native markup whitespace normalization, following the JSX/Babel rules:
+ *   - split the text node into lines;
+ *   - trim leading whitespace on every line but the first, and trailing
+ *     whitespace on every line but the last;
+ *   - drop lines that are empty after trimming;
+ *   - join the surviving lines with a single space.
+ * The net effect: indentation/newlines between block elements vanish, while a
+ * meaningful single space between inline content is preserved. Returns a new
+ * zend_string (possibly empty - the caller drops empty text nodes).
+ *
+ * One streaming pass: because a non-first line is left-trimmed and a non-last
+ * line is right-trimmed, any line that survives contains a non-whitespace
+ * character, so "join surviving lines with a single space" is simply a space
+ * before every surviving line except the first - no line table or lookahead
+ * for the last non-blank line is needed. A single-line text is untouched apart
+ * from the tab conversion, exactly as before. */
+zend_string *zend_markup_normalize_text(const char *text, size_t len)
+{
+	/* Output is never longer than the input. */
+	zend_string *result = zend_string_alloc(len, 0);
+	char *out = ZSTR_VAL(result);
+	size_t outlen = 0;
+	size_t pos = 0;
+	bool pending_join = false;
+
+	/* Line terminators are \r\n | \n | \r (matching JS String.split). A line
+	 * is "last" when no terminator follows it, so text ending in a line break
+	 * still right-trims its final content line, as the split-based version did
+	 * via its synthetic trailing empty line. */
+	for (;;) {
+		size_t e = pos;
+		while (e < len && text[e] != '\n' && text[e] != '\r') {
+			e++;
+		}
+		bool is_first = (pos == 0);
+		bool is_last = (e >= len);
+		size_t s = pos, en = e;
+
+		if (!is_first) {
+			while (s < en && (text[s] == ' ' || text[s] == '\t')) s++;
+		}
+		if (!is_last) {
+			while (en > s && (text[en - 1] == ' ' || text[en - 1] == '\t')) en--;
+		}
+		if (en > s) {
+			if (pending_join) {
+				out[outlen++] = ' ';
+			}
+			for (size_t x = s; x < en; x++) {
+				out[outlen++] = (text[x] == '\t') ? ' ' : text[x];
+			}
+			pending_join = true;
+		}
+
+		if (is_last) {
+			break;
+		}
+		if (text[e] == '\r' && e + 1 < len && text[e + 1] == '\n') {
+			e++;
+		}
+		pos = e + 1;
+	}
+
+	if (outlen == 0) {
+		zend_string_release(result);
+		return ZSTR_EMPTY_ALLOC();
+	}
+	ZSTR_LEN(result) = outlen;
+	out[outlen] = '\0';
+	return result;
+}
+
+/* Native markup character references. Markup text and literal
+ * attribute values decode HTML character references at compile time: the
+ * frozen WHATWG named set (semicolon-terminated forms only; the standard
+ * guarantees the list will never grow) plus numeric &#123; / &#x1F600; forms.
+ * Decoding is lenient like HTML and JSX: anything that does not parse as a
+ * reference - a bare "&", an unknown name, an out-of-range or surrogate
+ * codepoint - stays literal text, so "fish & chips" needs no escaping.
+ * Decoded text is a plain string escaped at render time, so "&amp;" in source
+ * round-trips to "&amp;" in output. Text decodes after whitespace
+ * normalization, so "&#32;" survives it (the entity spelling of JSX's {' '}). */
+
+static const zend_markup_entity *zend_markup_entity_lookup(const char *name, size_t len)
+{
+	uint32_t lo = 0, hi = ZEND_MARKUP_ENTITY_COUNT;
+
+	while (lo < hi) {
+		uint32_t mid = lo + (hi - lo) / 2;
+		const zend_markup_entity *e = &zend_markup_entities[mid];
+		int r = memcmp(name, e->name, MIN(len, e->name_len));
+		if (r == 0) {
+			r = (len > e->name_len) - (len < e->name_len);
+		}
+		if (r == 0) {
+			return e;
+		}
+		if (r < 0) {
+			hi = mid;
+		} else {
+			lo = mid + 1;
+		}
+	}
+	return NULL;
+}
+
+static size_t zend_markup_utf8_encode(char *out, uint32_t cp)
+{
+	if (cp < 0x80) {
+		out[0] = (char)cp;
+		return 1;
+	}
+	if (cp < 0x800) {
+		out[0] = (char)(0xC0 | (cp >> 6));
+		out[1] = (char)(0x80 | (cp & 0x3F));
+		return 2;
+	}
+	if (cp < 0x10000) {
+		out[0] = (char)(0xE0 | (cp >> 12));
+		out[1] = (char)(0x80 | ((cp >> 6) & 0x3F));
+		out[2] = (char)(0x80 | (cp & 0x3F));
+		return 3;
+	}
+	out[0] = (char)(0xF0 | (cp >> 18));
+	out[1] = (char)(0x80 | ((cp >> 12) & 0x3F));
+	out[2] = (char)(0x80 | ((cp >> 6) & 0x3F));
+	out[3] = (char)(0x80 | (cp & 0x3F));
+	return 4;
+}
+
+/* Takes ownership of str; returns it unchanged when it contains no "&". */
+zend_string *zend_markup_decode_entities(zend_string *str)
+{
+	const char *p = ZSTR_VAL(str);
+	const char *end = p + ZSTR_LEN(str);
+	const char *amp = memchr(p, '&', ZSTR_LEN(str));
+	smart_str buf = {0};
+
+	if (!amp) {
+		return str;
+	}
+
+	while (amp) {
+		const char *q = amp + 1;
+		const char *repl = NULL;
+		size_t repl_len = 0;
+		char utf8[4];
+
+		smart_str_appendl(&buf, p, amp - p);
+
+		if (q < end && *q == '#') {
+			/* Numeric reference: &#123; or &#x1F600; */
+			uint32_t cp = 0;
+			bool overflow = false, hex = false;
+			const char *digits;
+
+			q++;
+			if (q < end && (*q == 'x' || *q == 'X')) {
+				hex = true;
+				q++;
+			}
+			digits = q;
+			while (q < end) {
+				uint32_t d;
+				if (*q >= '0' && *q <= '9') {
+					d = *q - '0';
+				} else if (hex && *q >= 'a' && *q <= 'f') {
+					d = *q - 'a' + 10;
+				} else if (hex && *q >= 'A' && *q <= 'F') {
+					d = *q - 'A' + 10;
+				} else {
+					break;
+				}
+				if (cp > 0x10FFFF) {
+					overflow = true;
+				} else {
+					cp = cp * (hex ? 16 : 10) + d;
+				}
+				q++;
+			}
+			if (q > digits && q < end && *q == ';'
+					&& !overflow && cp > 0 && cp <= 0x10FFFF
+					&& !(cp >= 0xD800 && cp <= 0xDFFF)) {
+				repl_len = zend_markup_utf8_encode(utf8, cp);
+				repl = utf8;
+				q++;
+			}
+		} else {
+			/* Named reference: &name; (case-sensitive, ASCII alphanumeric) */
+			const char *name = q;
+			while (q < end && (size_t)(q - name) <= ZEND_MARKUP_ENTITY_MAX_NAME
+					&& ((*q >= 'a' && *q <= 'z') || (*q >= 'A' && *q <= 'Z')
+						|| (*q >= '0' && *q <= '9'))) {
+				q++;
+			}
+			if (q > name && q < end && *q == ';') {
+				const zend_markup_entity *e = zend_markup_entity_lookup(name, q - name);
+				if (e) {
+					repl = e->utf8;
+					repl_len = e->utf8_len;
+					q++;
+				}
+			}
+		}
+
+		if (repl) {
+			smart_str_appendl(&buf, repl, repl_len);
+			p = q;
+		} else {
+			smart_str_appendc(&buf, '&');
+			p = amp + 1;
+		}
+		amp = (p < end) ? memchr(p, '&', end - p) : NULL;
+	}
+	smart_str_appendl(&buf, p, end - p);
+
+	zend_string_release_ex(str, 0);
+	return smart_str_extract(&buf);
+}
+
+/* Native markup AST lowering.
+ * Lower a markup element into an ordinary `new \Html\Element(tag, [], [children])`
+ * (or `new \Html\Fragment([children])` when the tag name is empty) so no new AST
+ * node kind or zend_compile.c support is needed. `name` is the tag-name zval AST
+ * or NULL for a fragment; `children` is a ZEND_AST_ARRAY of ZEND_AST_ARRAY_ELEM.
+ *
+ * All lowering targets are named through the ZEND_MARKUP_*_FQ macros (see
+ * zend_markup.h) so the markup-to-runtime vocabulary has a single home. */
+
+/* Build a fully-qualified name AST for one of the ZEND_MARKUP_*_FQ symbols. */
+static zend_ast *zend_ast_markup_fq_name(const char *name, size_t len)
+{
+	zend_ast *ast = zend_ast_create_zval_from_str(zend_string_init(name, len, 0));
+	ast->attr = ZEND_NAME_FQ;
+	return ast;
+}
+
+/* Element vs component classification: a tag whose first character is
+ * uppercase, which is namespace-qualified (contains "\"), or which names a
+ * static method via "::", dispatches as a component; anything else is a literal
+ * HTML element. The single home for this rule: the compiler applies it to
+ * static tag names here, and Html\render_dynamic applies it to a dynamic tag's
+ * runtime value (hence ZEND_API). */
+ZEND_API bool zend_markup_name_is_component(zend_string *tag)
+{
+	return (ZSTR_LEN(tag) > 0 && ZSTR_VAL(tag)[0] >= 'A' && ZSTR_VAL(tag)[0] <= 'Z')
+		|| memchr(ZSTR_VAL(tag), '\\', ZSTR_LEN(tag)) != NULL
+		|| strstr(ZSTR_VAL(tag), "::") != NULL;
+}
+
+/* Wrap a list of children in `new \Html\Fragment([children])`. Consumes (and, if
+ * NULL, creates) the children list. */
+static zend_ast *zend_ast_wrap_fragment(zend_ast *children)
+{
+	if (children == NULL) {
+		children = zend_ast_create_list(0, ZEND_AST_ARRAY);
+	}
+	children->attr = ZEND_ARRAY_SYNTAX_SHORT;
+
+	zend_ast *frag_class = zend_ast_markup_fq_name(ZEND_STRL(ZEND_MARKUP_FRAGMENT_FQ));
+
+	return zend_ast_create(ZEND_AST_NEW, frag_class,
+		zend_ast_create_list(1, ZEND_AST_ARG_LIST, children));
+}
+
+/* Wrap a string AST in a `\Html\raw(...)` call (trusted passthrough). Used for
+ * `<!-- … -->` comments, which are emitted as literal HTML. */
+zend_ast *zend_ast_create_markup_raw(zend_ast *str)
+{
+	zend_ast *fn = zend_ast_markup_fq_name(ZEND_STRL(ZEND_MARKUP_RAW_FQ));
+	return zend_ast_create(ZEND_AST_CALL, fn,
+		zend_ast_create_list(1, ZEND_AST_ARG_LIST, str));
+}
+
+/* Wrap a children list in
+ * `new \Html\LazyFragment(fn() => new \Html\Fragment([children]))` (the
+ * `:lazy` directive). The arrow function defers building the child subtree -
+ * and running any side effects in its interpolations - until the component
+ * actually renders the slot, so a component that discards its body never
+ * evaluates it. Consumes `children`. */
+static zend_ast *zend_ast_wrap_lazy_fragment(zend_ast *children, uint32_t lineno)
+{
+	zend_ast *frag = zend_ast_wrap_fragment(children);
+
+	/* fn() => new \Html\Fragment([...]) - an arrow function so its body
+	 * auto-captures by value whatever it references, exactly as a hand-written
+	 * one would; only the expression evaluation is deferred. */
+	zend_ast *params = zend_ast_create_list(0, ZEND_AST_PARAM_LIST);
+	zend_ast *closure = zend_ast_create_decl(ZEND_AST_ARROW_FUNC, 0, lineno,
+		NULL, NULL, params, NULL, frag, NULL, NULL);
+
+	zend_ast *lazy_class = zend_ast_markup_fq_name(ZEND_STRL(ZEND_MARKUP_LAZY_FRAGMENT_FQ));
+	return zend_ast_create(ZEND_AST_NEW, lazy_class,
+		zend_ast_create_list(1, ZEND_AST_ARG_LIST, closure));
+}
+
+/* Detect and strip a bare `:lazy` directive from a component's attribute list.
+ * `:lazy` marks the component's body slot for lazy evaluation (see
+ * zend_ast_wrap_lazy_fragment); it is a compiler directive, not a prop, so it is
+ * removed from the list rather than passed on. Returns whether it was present. */
+static bool zend_markup_extract_lazy(zend_ast *attrs)
+{
+	if (attrs == NULL) {
+		return false;
+	}
+	zend_ast_list *list = zend_ast_get_list(attrs);
+	for (uint32_t i = 0; i < list->children; i++) {
+		zend_ast *elem = list->child[i];
+		if (elem == NULL || elem->kind != ZEND_AST_ARRAY_ELEM || elem->child[1] == NULL) {
+			continue;
+		}
+		zval *key = zend_ast_get_zval(elem->child[1]);
+		if (Z_TYPE_P(key) == IS_STRING && zend_string_equals_literal(Z_STR_P(key), ":lazy")) {
+			zend_ast_destroy(elem);
+			for (uint32_t j = i; j + 1 < list->children; j++) {
+				list->child[j] = list->child[j + 1];
+			}
+			list->children--;
+			return true;
+		}
+	}
+	return false;
+}
+
+/* Lower a component tag (a capitalized or namespace-qualified name, or
+ * "Class::method") into a call to \Html\render_component(component, props, slot)
+ * Attributes become the props array and the body content becomes a
+ * single \Html\Fragment passed as the slot (or a lazy \Html\LazyFragment when
+ * the `:lazy` directive is present).
+ *
+ * Component resolution is two-stage, and every tag resolves through the *class*
+ * name rules only: a bare/qualified tag lowers to ZEND_AST_CLASS_NAME (the
+ * `Component::class` machinery), and a "Class::method" tag lowers the class
+ * part the same way with "::method" appended - both honor `use` imports and
+ * the current namespace, with a leading "\" fully qualified. The runtime then
+ * resolves the name to a class implementing Html\Htmlable (instantiated) or a
+ * public static method (called) - see PHP_FUNCTION(Html_render_component) in
+ * ext/html/html.c.
+ *
+ * Plain *function* components are deliberately out of v1: a bare tag gives no
+ * signal whether a class or a function is meant, and functions resolve through
+ * the separate `use function` import table, so supporting them would need a
+ * second compile-time resolution and a new AST kind to carry it. A static
+ * method has no such ambiguity - its class part resolves like any class. */
+static zend_ast *zend_ast_create_markup_component(zend_ast *name, zend_ast *attrs, zend_ast *children)
+{
+	uint32_t lineno = zend_ast_get_lineno(name);
+	zend_string *tag = zend_ast_get_str(name);
+	const char *sep = strstr(ZSTR_VAL(tag), "::");
+	/* A leading "\" is a fully-qualified reference; otherwise resolve the name
+	 * (unqualified or qualified) against the current use/namespace. */
+	uint32_t name_type = (ZSTR_VAL(tag)[0] == '\\') ? ZEND_NAME_FQ : ZEND_NAME_NOT_FQ;
+	zend_ast *component_name;
+
+	if (sep != NULL) {
+		/* "Class::method": resolve the class part as a class, then append
+		 * "::method". */
+		size_t class_len = sep - ZSTR_VAL(tag);
+		zend_ast *class_name = zend_ast_create_zval_from_str(
+			zend_string_init(ZSTR_VAL(tag), class_len, 0));
+		class_name->attr = name_type;
+
+		zval suffix;
+		ZVAL_STR(&suffix, zend_string_init(sep, ZSTR_LEN(tag) - class_len, 0));
+		component_name = zend_ast_create_concat_op(
+			zend_ast_create(ZEND_AST_CLASS_NAME, class_name),
+			zend_ast_create_zval(&suffix));
+	} else {
+		zend_ast *class_name = zend_ast_create_zval_from_str(zend_string_copy(tag));
+		class_name->attr = name_type;
+		component_name = zend_ast_create(ZEND_AST_CLASS_NAME, class_name);
+	}
+	zend_ast_destroy(name);
+
+	if (attrs == NULL) {
+		attrs = zend_ast_create_list(0, ZEND_AST_ARRAY);
+	}
+	attrs->attr = ZEND_ARRAY_SYNTAX_SHORT;
+
+	/* The `:lazy` directive is a compiler marker, not a prop - strip it first. */
+	bool lazy = zend_markup_extract_lazy(attrs);
+
+	/* The body becomes a single slot Fragment, or null when there is no body.
+	 * With `:lazy` the fragment is wrapped in a deferred Html\LazyFragment. */
+	zend_ast *slot;
+	if (children != NULL && zend_ast_get_list(children)->children > 0) {
+		children->attr = ZEND_ARRAY_SYNTAX_SHORT;
+		slot = lazy
+			? zend_ast_wrap_lazy_fragment(children, lineno)
+			: zend_ast_wrap_fragment(children);
+	} else {
+		if (children != NULL) {
+			zend_ast_destroy(children);
+		}
+		zval null_zv;
+		ZVAL_NULL(&null_zv);
+		slot = zend_ast_create_zval(&null_zv);
+	}
+
+	zend_ast *fn = zend_ast_markup_fq_name(ZEND_STRL(ZEND_MARKUP_COMPONENT_FQ));
+
+	zend_ast *args = zend_ast_create_list(0, ZEND_AST_ARG_LIST);
+	args = zend_ast_list_add(args, component_name);
+	args = zend_ast_list_add(args, attrs);
+	args = zend_ast_list_add(args, slot);
+
+	return zend_ast_create(ZEND_AST_CALL, fn, args);
+}
+
+zend_ast *zend_ast_create_markup_element(zend_ast *name, zend_ast *attrs, zend_ast *children)
+{
+	zend_ast *class_name, *args, *result;
+
+	/* NULL children (a self-closed tag) means an empty list. A fragment always
+	 * has a children list (the grammar builds one as content begins). */
+	if (children == NULL) {
+		children = zend_ast_create_list(0, ZEND_AST_ARRAY);
+	}
+
+	/* The grammar reduces a markup element only once its closing tag has been
+	 * scanned, so nodes created here would inherit the *close* line. Stamp the
+	 * lowered expression with the line the element opens on instead, so errors
+	 * in a multi-line element report like any multi-line call. The tag-name
+	 * token carries that line; a fragment has none, but its children list is
+	 * created as content begins. */
+	uint32_t lineno = (name != NULL)
+		? zend_ast_get_lineno(name) : zend_ast_get_lineno(children);
+
+	/* A capitalized name, a namespace-qualified name, or one containing "::"
+	 * is a component. */
+	if (name != NULL && zend_markup_name_is_component(zend_ast_get_str(name))) {
+		result = zend_ast_create_markup_component(name, attrs, children);
+		result->lineno = lineno;
+		return result;
+	}
+
+	children->attr = ZEND_ARRAY_SYNTAX_SHORT;
+
+	args = zend_ast_create_list(0, ZEND_AST_ARG_LIST);
+
+	if (name == NULL) {
+		/* A fragment has no attributes (the grammar forbids them on `<>`). */
+		if (attrs != NULL) {
+			zend_ast_destroy(attrs);
+		}
+		class_name = zend_ast_markup_fq_name(ZEND_STRL(ZEND_MARKUP_FRAGMENT_FQ));
+		args = zend_ast_list_add(args, children);
+	} else {
+		if (attrs == NULL) {
+			attrs = zend_ast_create_list(0, ZEND_AST_ARRAY);
+		}
+		attrs->attr = ZEND_ARRAY_SYNTAX_SHORT;
+		class_name = zend_ast_markup_fq_name(ZEND_STRL(ZEND_MARKUP_ELEMENT_FQ));
+		args = zend_ast_list_add(args, name);
+		args = zend_ast_list_add(args, attrs);
+		args = zend_ast_list_add(args, children);
+	}
+
+	result = zend_ast_create(ZEND_AST_NEW, class_name, args);
+	result->lineno = lineno;
+	return result;
+}
+
+/* Build a markup element (or, with `dynamic`, a dynamic tag) after checking
+ * the closing tag matches the opener: `<div>…</span>` and
+ * `<$a>…</$b>` are compile errors alike. Both `open` and `close` NULL means a
+ * `<>…</>` fragment. `close` is consumed. */
+zend_ast *zend_ast_create_markup_checked(zend_ast *open, zend_ast *attrs, zend_ast *children, zend_ast *close, bool dynamic)
+{
+	bool match;
+	if (open == NULL || close == NULL) {
+		match = (open == NULL && close == NULL);
+	} else {
+		match = zend_string_equals(Z_STR_P(zend_ast_get_zval(open)), Z_STR_P(zend_ast_get_zval(close)));
+	}
+	if (!match) {
+		const char *sigil = dynamic ? "$" : "";
+		zend_throw_exception_ex(zend_ce_compile_error, 0,
+			"Mismatched markup closing tag: expected </%s%s>, found </%s%s>",
+			sigil, open ? Z_STRVAL_P(zend_ast_get_zval(open)) : "",
+			sigil, close ? Z_STRVAL_P(zend_ast_get_zval(close)) : "");
+		if (open != NULL) {
+			zend_ast_destroy(open);
+		}
+		if (attrs != NULL) {
+			zend_ast_destroy(attrs);
+		}
+		if (children != NULL) {
+			zend_ast_destroy(children);
+		}
+		if (close != NULL) {
+			zend_ast_destroy(close);
+		}
+		return NULL;
+	}
+	if (close != NULL) {
+		zend_ast_destroy(close);
+	}
+
+	return dynamic
+		? zend_ast_create_markup_dynamic(open, attrs, children)
+		: zend_ast_create_markup_element(open, attrs, children);
+}
+
+/* Build the \Html\render_dynamic(tag_expr, attributes, children) call both
+ * dynamic-tag forms lower into. `tag_expr` is an already-built expression AST
+ * producing the tag name; `lineno` is the opening-tag line (see
+ * zend_ast_create_markup_element for why it is stamped explicitly). */
+static zend_ast *zend_markup_dynamic_call(zend_ast *tag_expr, zend_ast *attrs, zend_ast *children, uint32_t lineno)
+{
+	if (attrs == NULL) {
+		attrs = zend_ast_create_list(0, ZEND_AST_ARRAY);
+	}
+	attrs->attr = ZEND_ARRAY_SYNTAX_SHORT;
+
+	if (children == NULL) {
+		children = zend_ast_create_list(0, ZEND_AST_ARRAY);
+	}
+	children->attr = ZEND_ARRAY_SYNTAX_SHORT;
+
+	zend_ast *fn = zend_ast_markup_fq_name(ZEND_STRL(ZEND_MARKUP_DYNAMIC_FQ));
+
+	zend_ast *args = zend_ast_create_list(0, ZEND_AST_ARG_LIST);
+	args = zend_ast_list_add(args, tag_expr);
+	args = zend_ast_list_add(args, attrs);
+	args = zend_ast_list_add(args, children);
+
+	zend_ast *result = zend_ast_create(ZEND_AST_CALL, fn, args);
+	result->lineno = lineno;
+	return result;
+}
+
+/* Lower a dynamic tag `<$tag …>…</$tag>` into a call to
+ * \Html\render_dynamic($tag, attributes, children). The variable's runtime
+ * value decides what a static tag name decides at compile time, by the same
+ * classification rule (zend_markup_name_is_component); only classification
+ * moves to runtime. `name` is the T_VARIABLE zval AST (without the "$"). */
+zend_ast *zend_ast_create_markup_dynamic(zend_ast *name, zend_ast *attrs, zend_ast *children)
+{
+	uint32_t lineno = zend_ast_get_lineno(name);
+
+	zend_ast *var = zend_ast_create(ZEND_AST_VAR, name);
+	var->lineno = lineno;
+
+	return zend_markup_dynamic_call(var, attrs, children, lineno);
+}
+
+/* The brace form `<{expr} …>…</>` / `<{expr} …/>`: the tag is an arbitrary
+ * expression, evaluated once. It closes anonymously (`</>`, like a fragment)
+ * because a closing tag cannot restate the expression - re-evaluating it
+ * would run its side effects twice, and matching it textually is meaningless
+ * for computed values. */
+zend_ast *zend_ast_create_markup_dynamic_expr(zend_ast *expr, zend_ast *attrs, zend_ast *children)
+{
+	return zend_markup_dynamic_call(expr, attrs, children, zend_ast_get_lineno(expr));
+}
diff --git a/Zend/zend_markup.h b/Zend/zend_markup.h
new file mode 100644
index 000000000000..35644855295c
--- /dev/null
+++ b/Zend/zend_markup.h
@@ -0,0 +1,67 @@
+/*
+   +----------------------------------------------------------------------+
+   | Zend Engine                                                          |
+   +----------------------------------------------------------------------+
+   | Copyright © Zend Technologies Ltd., a subsidiary company of          |
+   |     Perforce Software, Inc., and Contributors.                       |
+   +----------------------------------------------------------------------+
+   | This source file is subject to the Modified BSD License that is      |
+   | bundled with this package in the file LICENSE, and is available      |
+   | through the World Wide Web at <https://www.php.net/license/>.        |
+   |                                                                      |
+   | SPDX-License-Identifier: BSD-3-Clause                                |
+   +----------------------------------------------------------------------+
+   | Author: Liam Hammett                                                 |
+   +----------------------------------------------------------------------+
+*/
+
+#ifndef ZEND_MARKUP_H
+#define ZEND_MARKUP_H
+
+#include "zend_ast.h"
+
+/* The fully-qualified names that Native Markup Expressions
+ * lowers into. This is the single home for the markup-to-runtime vocabulary:
+ * the parser (Zend/zend_language_parser.y) lowers markup expressions to exactly
+ * these symbols, and the ext/html runtime registers exactly them (asserted at
+ * MINIT, see PHP_MINIT_FUNCTION(html)).
+ *
+ * Renaming the markup namespace (e.g. the open `Html\` vs `PHP\Html\` question)
+ * is a one-line edit here rather than a hunt across the parser, stub, and
+ * runtime. Keep in sync with ext/html/html.stub.php, which declares the classes
+ * and functions these names refer to. */
+
+#define ZEND_MARKUP_ELEMENT_FQ        "Html\\Element"
+#define ZEND_MARKUP_FRAGMENT_FQ       "Html\\Fragment"
+#define ZEND_MARKUP_LAZY_FRAGMENT_FQ  "Html\\LazyFragment"
+#define ZEND_MARKUP_RAW_FQ            "Html\\raw"
+#define ZEND_MARKUP_COMPONENT_FQ      "Html\\render_component"
+#define ZEND_MARKUP_DYNAMIC_FQ        "Html\\render_dynamic"
+
+BEGIN_EXTERN_C()
+
+/* Element vs component classification: uppercase first character,
+ * a "\", or a "::" dispatches as a component; anything else is a literal HTML
+ * element. The single home for this rule - the compiler applies it to static
+ * tag names, and Html\render_dynamic applies it to a dynamic tag's runtime
+ * value, so `<$tag>` decides at runtime exactly what `<tag>` decides at
+ * compile time. */
+ZEND_API bool zend_markup_name_is_component(zend_string *tag);
+
+/* Compile-time text handling, called by the lexer (zend_language_scanner.l) on
+ * markup text nodes and literal attribute values. Both live in zend_markup.c. */
+zend_string *zend_markup_normalize_text(const char *text, size_t len);
+zend_string *zend_markup_decode_entities(zend_string *str);
+
+/* AST lowering, called by the markup grammar actions (zend_language_parser.y).
+ * Each returns NULL with a CompileError exception pending on invalid markup
+ * (e.g. a mismatched closing tag); the grammar action then YYERRORs. */
+zend_ast *zend_ast_create_markup_raw(zend_ast *str);
+zend_ast *zend_ast_create_markup_element(zend_ast *name, zend_ast *attrs, zend_ast *children);
+zend_ast *zend_ast_create_markup_checked(zend_ast *open, zend_ast *attrs, zend_ast *children, zend_ast *close, bool dynamic);
+zend_ast *zend_ast_create_markup_dynamic(zend_ast *name, zend_ast *attrs, zend_ast *children);
+zend_ast *zend_ast_create_markup_dynamic_expr(zend_ast *expr, zend_ast *attrs, zend_ast *children);
+
+END_EXTERN_C()
+
+#endif /* ZEND_MARKUP_H */
diff --git a/Zend/zend_markup_entities.h b/Zend/zend_markup_entities.h
new file mode 100644
index 000000000000..8611ee080df5
--- /dev/null
+++ b/Zend/zend_markup_entities.h
@@ -0,0 +1,2149 @@
+/* This is a generated file - edit Zend/zend_markup_entities_gen.php instead.
+ * Source data: ext/standard/html_tables/ents_html5.txt (the WHATWG HTML5
+ * named-reference table, frozen by the HTML standard; also feeds
+ * html_entity_decode()). Canonical semicolon-terminated forms only; sorted
+ * by name in byte order for bsearch. */
+
+#ifndef ZEND_MARKUP_ENTITIES_H
+#define ZEND_MARKUP_ENTITIES_H
+
+typedef struct _zend_markup_entity {
+	const char *name;   /* without the leading '&' and trailing ';' */
+	const char *utf8;   /* replacement text, UTF-8 */
+	uint8_t name_len;
+	uint8_t utf8_len;
+} zend_markup_entity;
+
+#define ZEND_MARKUP_ENTITY_COUNT 2125
+#define ZEND_MARKUP_ENTITY_MAX_NAME 31
+#define ZEND_MARKUP_ENTITY_MAX_UTF8 6
+
+static const zend_markup_entity zend_markup_entities[ZEND_MARKUP_ENTITY_COUNT] = {
+	{"AElig", "\xC3\x86", 5, 2},
+	{"AMP", "\x26", 3, 1},
+	{"Aacute", "\xC3\x81", 6, 2},
+	{"Abreve", "\xC4\x82", 6, 2},
+	{"Acirc", "\xC3\x82", 5, 2},
+	{"Acy", "\xD0\x90", 3, 2},
+	{"Afr", "\xF0\x9D\x94\x84", 3, 4},
+	{"Agrave", "\xC3\x80", 6, 2},
+	{"Alpha", "\xCE\x91", 5, 2},
+	{"Amacr", "\xC4\x80", 5, 2},
+	{"And", "\xE2\xA9\x93", 3, 3},
+	{"Aogon", "\xC4\x84", 5, 2},
+	{"Aopf", "\xF0\x9D\x94\xB8", 4, 4},
+	{"ApplyFunction", "\xE2\x81\xA1", 13, 3},
+	{"Aring", "\xC3\x85", 5, 2},
+	{"Ascr", "\xF0\x9D\x92\x9C", 4, 4},
+	{"Assign", "\xE2\x89\x94", 6, 3},
+	{"Atilde", "\xC3\x83", 6, 2},
+	{"Auml", "\xC3\x84", 4, 2},
+	{"Backslash", "\xE2\x88\x96", 9, 3},
+	{"Barv", "\xE2\xAB\xA7", 4, 3},
+	{"Barwed", "\xE2\x8C\x86", 6, 3},
+	{"Bcy", "\xD0\x91", 3, 2},
+	{"Because", "\xE2\x88\xB5", 7, 3},
+	{"Bernoullis", "\xE2\x84\xAC", 10, 3},
+	{"Beta", "\xCE\x92", 4, 2},
+	{"Bfr", "\xF0\x9D\x94\x85", 3, 4},
+	{"Bopf", "\xF0\x9D\x94\xB9", 4, 4},
+	{"Breve", "\xCB\x98", 5, 2},
+	{"Bscr", "\xE2\x84\xAC", 4, 3},
+	{"Bumpeq", "\xE2\x89\x8E", 6, 3},
+	{"CHcy", "\xD0\xA7", 4, 2},
+	{"COPY", "\xC2\xA9", 4, 2},
+	{"Cacute", "\xC4\x86", 6, 2},
+	{"Cap", "\xE2\x8B\x92", 3, 3},
+	{"CapitalDifferentialD", "\xE2\x85\x85", 20, 3},
+	{"Cayleys", "\xE2\x84\xAD", 7, 3},
+	{"Ccaron", "\xC4\x8C", 6, 2},
+	{"Ccedil", "\xC3\x87", 6, 2},
+	{"Ccirc", "\xC4\x88", 5, 2},
+	{"Cconint", "\xE2\x88\xB0", 7, 3},
+	{"Cdot", "\xC4\x8A", 4, 2},
+	{"Cedilla", "\xC2\xB8", 7, 2},
+	{"CenterDot", "\xC2\xB7", 9, 2},
+	{"Cfr", "\xE2\x84\xAD", 3, 3},
+	{"Chi", "\xCE\xA7", 3, 2},
+	{"CircleDot", "\xE2\x8A\x99", 9, 3},
+	{"CircleMinus", "\xE2\x8A\x96", 11, 3},
+	{"CirclePlus", "\xE2\x8A\x95", 10, 3},
+	{"CircleTimes", "\xE2\x8A\x97", 11, 3},
+	{"ClockwiseContourIntegral", "\xE2\x88\xB2", 24, 3},
+	{"CloseCurlyDoubleQuote", "\xE2\x80\x9D", 21, 3},
+	{"CloseCurlyQuote", "\xE2\x80\x99", 15, 3},
+	{"Colon", "\xE2\x88\xB7", 5, 3},
+	{"Colone", "\xE2\xA9\xB4", 6, 3},
+	{"Congruent", "\xE2\x89\xA1", 9, 3},
+	{"Conint", "\xE2\x88\xAF", 6, 3},
+	{"ContourIntegral", "\xE2\x88\xAE", 15, 3},
+	{"Copf", "\xE2\x84\x82", 4, 3},
+	{"Coproduct", "\xE2\x88\x90", 9, 3},
+	{"CounterClockwiseContourIntegral", "\xE2\x88\xB3", 31, 3},
+	{"Cross", "\xE2\xA8\xAF", 5, 3},
+	{"Cscr", "\xF0\x9D\x92\x9E", 4, 4},
+	{"Cup", "\xE2\x8B\x93", 3, 3},
+	{"CupCap", "\xE2\x89\x8D", 6, 3},
+	{"DD", "\xE2\x85\x85", 2, 3},
+	{"DDotrahd", "\xE2\xA4\x91", 8, 3},
+	{"DJcy", "\xD0\x82", 4, 2},
+	{"DScy", "\xD0\x85", 4, 2},
+	{"DZcy", "\xD0\x8F", 4, 2},
+	{"Dagger", "\xE2\x80\xA1", 6, 3},
+	{"Darr", "\xE2\x86\xA1", 4, 3},
+	{"Dashv", "\xE2\xAB\xA4", 5, 3},
+	{"Dcaron", "\xC4\x8E", 6, 2},
+	{"Dcy", "\xD0\x94", 3, 2},
+	{"Del", "\xE2\x88\x87", 3, 3},
+	{"Delta", "\xCE\x94", 5, 2},
+	{"Dfr", "\xF0\x9D\x94\x87", 3, 4},
+	{"DiacriticalAcute", "\xC2\xB4", 16, 2},
+	{"DiacriticalDot", "\xCB\x99", 14, 2},
+	{"DiacriticalDoubleAcute", "\xCB\x9D", 22, 2},
+	{"DiacriticalGrave", "\x60", 16, 1},
+	{"DiacriticalTilde", "\xCB\x9C", 16, 2},
+	{"Diamond", "\xE2\x8B\x84", 7, 3},
+	{"DifferentialD", "\xE2\x85\x86", 13, 3},
+	{"Dopf", "\xF0\x9D\x94\xBB", 4, 4},
+	{"Dot", "\xC2\xA8", 3, 2},
+	{"DotDot", "\xE2\x83\x9C", 6, 3},
+	{"DotEqual", "\xE2\x89\x90", 8, 3},
+	{"DoubleContourIntegral", "\xE2\x88\xAF", 21, 3},
+	{"DoubleDot", "\xC2\xA8", 9, 2},
+	{"DoubleDownArrow", "\xE2\x87\x93", 15, 3},
+	{"DoubleLeftArrow", "\xE2\x87\x90", 15, 3},
+	{"DoubleLeftRightArrow", "\xE2\x87\x94", 20, 3},
+	{"DoubleLeftTee", "\xE2\xAB\xA4", 13, 3},
+	{"DoubleLongLeftArrow", "\xE2\x9F\xB8", 19, 3},
+	{"DoubleLongLeftRightArrow", "\xE2\x9F\xBA", 24, 3},
+	{"DoubleLongRightArrow", "\xE2\x9F\xB9", 20, 3},
+	{"DoubleRightArrow", "\xE2\x87\x92", 16, 3},
+	{"DoubleRightTee", "\xE2\x8A\xA8", 14, 3},
+	{"DoubleUpArrow", "\xE2\x87\x91", 13, 3},
+	{"DoubleUpDownArrow", "\xE2\x87\x95", 17, 3},
+	{"DoubleVerticalBar", "\xE2\x88\xA5", 17, 3},
+	{"DownArrow", "\xE2\x86\x93", 9, 3},
+	{"DownArrowBar", "\xE2\xA4\x93", 12, 3},
+	{"DownArrowUpArrow", "\xE2\x87\xB5", 16, 3},
+	{"DownBreve", "\xCC\x91", 9, 2},
+	{"DownLeftRightVector", "\xE2\xA5\x90", 19, 3},
+	{"DownLeftTeeVector", "\xE2\xA5\x9E", 17, 3},
+	{"DownLeftVector", "\xE2\x86\xBD", 14, 3},
+	{"DownLeftVectorBar", "\xE2\xA5\x96", 17, 3},
+	{"DownRightTeeVector", "\xE2\xA5\x9F", 18, 3},
+	{"DownRightVector", "\xE2\x87\x81", 15, 3},
+	{"DownRightVectorBar", "\xE2\xA5\x97", 18, 3},
+	{"DownTee", "\xE2\x8A\xA4", 7, 3},
+	{"DownTeeArrow", "\xE2\x86\xA7", 12, 3},
+	{"Downarrow", "\xE2\x87\x93", 9, 3},
+	{"Dscr", "\xF0\x9D\x92\x9F", 4, 4},
+	{"Dstrok", "\xC4\x90", 6, 2},
+	{"ENG", "\xC5\x8A", 3, 2},
+	{"ETH", "\xC3\x90", 3, 2},
+	{"Eacute", "\xC3\x89", 6, 2},
+	{"Ecaron", "\xC4\x9A", 6, 2},
+	{"Ecirc", "\xC3\x8A", 5, 2},
+	{"Ecy", "\xD0\xAD", 3, 2},
+	{"Edot", "\xC4\x96", 4, 2},
+	{"Efr", "\xF0\x9D\x94\x88", 3, 4},
+	{"Egrave", "\xC3\x88", 6, 2},
+	{"Element", "\xE2\x88\x88", 7, 3},
+	{"Emacr", "\xC4\x92", 5, 2},
+	{"EmptySmallSquare", "\xE2\x97\xBB", 16, 3},
+	{"EmptyVerySmallSquare", "\xE2\x96\xAB", 20, 3},
+	{"Eogon", "\xC4\x98", 5, 2},
+	{"Eopf", "\xF0\x9D\x94\xBC", 4, 4},
+	{"Epsilon", "\xCE\x95", 7, 2},
+	{"Equal", "\xE2\xA9\xB5", 5, 3},
+	{"EqualTilde", "\xE2\x89\x82", 10, 3},
+	{"Equilibrium", "\xE2\x87\x8C", 11, 3},
+	{"Escr", "\xE2\x84\xB0", 4, 3},
+	{"Esim", "\xE2\xA9\xB3", 4, 3},
+	{"Eta", "\xCE\x97", 3, 2},
+	{"Euml", "\xC3\x8B", 4, 2},
+	{"Exists", "\xE2\x88\x83", 6, 3},
+	{"ExponentialE", "\xE2\x85\x87", 12, 3},
+	{"Fcy", "\xD0\xA4", 3, 2},
+	{"Ffr", "\xF0\x9D\x94\x89", 3, 4},
+	{"FilledSmallSquare", "\xE2\x97\xBC", 17, 3},
+	{"FilledVerySmallSquare", "\xE2\x96\xAA", 21, 3},
+	{"Fopf", "\xF0\x9D\x94\xBD", 4, 4},
+	{"ForAll", "\xE2\x88\x80", 6, 3},
+	{"Fouriertrf", "\xE2\x84\xB1", 10, 3},
+	{"Fscr", "\xE2\x84\xB1", 4, 3},
+	{"GJcy", "\xD0\x83", 4, 2},
+	{"GT", "\x3E", 2, 1},
+	{"Gamma", "\xCE\x93", 5, 2},
+	{"Gammad", "\xCF\x9C", 6, 2},
+	{"Gbreve", "\xC4\x9E", 6, 2},
+	{"Gcedil", "\xC4\xA2", 6, 2},
+	{"Gcirc", "\xC4\x9C", 5, 2},
+	{"Gcy", "\xD0\x93", 3, 2},
+	{"Gdot", "\xC4\xA0", 4, 2},
+	{"Gfr", "\xF0\x9D\x94\x8A", 3, 4},
+	{"Gg", "\xE2\x8B\x99", 2, 3},
+	{"Gopf", "\xF0\x9D\x94\xBE", 4, 4},
+	{"GreaterEqual", "\xE2\x89\xA5", 12, 3},
+	{"GreaterEqualLess", "\xE2\x8B\x9B", 16, 3},
+	{"GreaterFullEqual", "\xE2\x89\xA7", 16, 3},
+	{"GreaterGreater", "\xE2\xAA\xA2", 14, 3},
+	{"GreaterLess", "\xE2\x89\xB7", 11, 3},
+	{"GreaterSlantEqual", "\xE2\xA9\xBE", 17, 3},
+	{"GreaterTilde", "\xE2\x89\xB3", 12, 3},
+	{"Gscr", "\xF0\x9D\x92\xA2", 4, 4},
+	{"Gt", "\xE2\x89\xAB", 2, 3},
+	{"HARDcy", "\xD0\xAA", 6, 2},
+	{"Hacek", "\xCB\x87", 5, 2},
+	{"Hat", "\x5E", 3, 1},
+	{"Hcirc", "\xC4\xA4", 5, 2},
+	{"Hfr", "\xE2\x84\x8C", 3, 3},
+	{"HilbertSpace", "\xE2\x84\x8B", 12, 3},
+	{"Hopf", "\xE2\x84\x8D", 4, 3},
+	{"HorizontalLine", "\xE2\x94\x80", 14, 3},
+	{"Hscr", "\xE2\x84\x8B", 4, 3},
+	{"Hstrok", "\xC4\xA6", 6, 2},
+	{"HumpDownHump", "\xE2\x89\x8E", 12, 3},
+	{"HumpEqual", "\xE2\x89\x8F", 9, 3},
+	{"IEcy", "\xD0\x95", 4, 2},
+	{"IJlig", "\xC4\xB2", 5, 2},
+	{"IOcy", "\xD0\x81", 4, 2},
+	{"Iacute", "\xC3\x8D", 6, 2},
+	{"Icirc", "\xC3\x8E", 5, 2},
+	{"Icy", "\xD0\x98", 3, 2},
+	{"Idot", "\xC4\xB0", 4, 2},
+	{"Ifr", "\xE2\x84\x91", 3, 3},
+	{"Igrave", "\xC3\x8C", 6, 2},
+	{"Im", "\xE2\x84\x91", 2, 3},
+	{"Imacr", "\xC4\xAA", 5, 2},
+	{"ImaginaryI", "\xE2\x85\x88", 10, 3},
+	{"Implies", "\xE2\x87\x92", 7, 3},
+	{"Int", "\xE2\x88\xAC", 3, 3},
+	{"Integral", "\xE2\x88\xAB", 8, 3},
+	{"Intersection", "\xE2\x8B\x82", 12, 3},
+	{"InvisibleComma", "\xE2\x81\xA3", 14, 3},
+	{"InvisibleTimes", "\xE2\x81\xA2", 14, 3},
+	{"Iogon", "\xC4\xAE", 5, 2},
+	{"Iopf", "\xF0\x9D\x95\x80", 4, 4},
+	{"Iota", "\xCE\x99", 4, 2},
+	{"Iscr", "\xE2\x84\x90", 4, 3},
+	{"Itilde", "\xC4\xA8", 6, 2},
+	{"Iukcy", "\xD0\x86", 5, 2},
+	{"Iuml", "\xC3\x8F", 4, 2},
+	{"Jcirc", "\xC4\xB4", 5, 2},
+	{"Jcy", "\xD0\x99", 3, 2},
+	{"Jfr", "\xF0\x9D\x94\x8D", 3, 4},
+	{"Jopf", "\xF0\x9D\x95\x81", 4, 4},
+	{"Jscr", "\xF0\x9D\x92\xA5", 4, 4},
+	{"Jsercy", "\xD0\x88", 6, 2},
+	{"Jukcy", "\xD0\x84", 5, 2},
+	{"KHcy", "\xD0\xA5", 4, 2},
+	{"KJcy", "\xD0\x8C", 4, 2},
+	{"Kappa", "\xCE\x9A", 5, 2},
+	{"Kcedil", "\xC4\xB6", 6, 2},
+	{"Kcy", "\xD0\x9A", 3, 2},
+	{"Kfr", "\xF0\x9D\x94\x8E", 3, 4},
+	{"Kopf", "\xF0\x9D\x95\x82", 4, 4},
+	{"Kscr", "\xF0\x9D\x92\xA6", 4, 4},
+	{"LJcy", "\xD0\x89", 4, 2},
+	{"LT", "\x3C", 2, 1},
+	{"Lacute", "\xC4\xB9", 6, 2},
+	{"Lambda", "\xCE\x9B", 6, 2},
+	{"Lang", "\xE2\x9F\xAA", 4, 3},
+	{"Laplacetrf", "\xE2\x84\x92", 10, 3},
+	{"Larr", "\xE2\x86\x9E", 4, 3},
+	{"Lcaron", "\xC4\xBD", 6, 2},
+	{"Lcedil", "\xC4\xBB", 6, 2},
+	{"Lcy", "\xD0\x9B", 3, 2},
+	{"LeftAngleBracket", "\xE2\x9F\xA8", 16, 3},
+	{"LeftArrow", "\xE2\x86\x90", 9, 3},
+	{"LeftArrowBar", "\xE2\x87\xA4", 12, 3},
+	{"LeftArrowRightArrow", "\xE2\x87\x86", 19, 3},
+	{"LeftCeiling", "\xE2\x8C\x88", 11, 3},
+	{"LeftDoubleBracket", "\xE2\x9F\xA6", 17, 3},
+	{"LeftDownTeeVector", "\xE2\xA5\xA1", 17, 3},
+	{"LeftDownVector", "\xE2\x87\x83", 14, 3},
+	{"LeftDownVectorBar", "\xE2\xA5\x99", 17, 3},
+	{"LeftFloor", "\xE2\x8C\x8A", 9, 3},
+	{"LeftRightArrow", "\xE2\x86\x94", 14, 3},
+	{"LeftRightVector", "\xE2\xA5\x8E", 15, 3},
+	{"LeftTee", "\xE2\x8A\xA3", 7, 3},
+	{"LeftTeeArrow", "\xE2\x86\xA4", 12, 3},
+	{"LeftTeeVector", "\xE2\xA5\x9A", 13, 3},
+	{"LeftTriangle", "\xE2\x8A\xB2", 12, 3},
+	{"LeftTriangleBar", "\xE2\xA7\x8F", 15, 3},
+	{"LeftTriangleEqual", "\xE2\x8A\xB4", 17, 3},
+	{"LeftUpDownVector", "\xE2\xA5\x91", 16, 3},
+	{"LeftUpTeeVector", "\xE2\xA5\xA0", 15, 3},
+	{"LeftUpVector", "\xE2\x86\xBF", 12, 3},
+	{"LeftUpVectorBar", "\xE2\xA5\x98", 15, 3},
+	{"LeftVector", "\xE2\x86\xBC", 10, 3},
+	{"LeftVectorBar", "\xE2\xA5\x92", 13, 3},
+	{"Leftarrow", "\xE2\x87\x90", 9, 3},
+	{"Leftrightarrow", "\xE2\x87\x94", 14, 3},
+	{"LessEqualGreater", "\xE2\x8B\x9A", 16, 3},
+	{"LessFullEqual", "\xE2\x89\xA6", 13, 3},
+	{"LessGreater", "\xE2\x89\xB6", 11, 3},
+	{"LessLess", "\xE2\xAA\xA1", 8, 3},
+	{"LessSlantEqual", "\xE2\xA9\xBD", 14, 3},
+	{"LessTilde", "\xE2\x89\xB2", 9, 3},
+	{"Lfr", "\xF0\x9D\x94\x8F", 3, 4},
+	{"Ll", "\xE2\x8B\x98", 2, 3},
+	{"Lleftarrow", "\xE2\x87\x9A", 10, 3},
+	{"Lmidot", "\xC4\xBF", 6, 2},
+	{"LongLeftArrow", "\xE2\x9F\xB5", 13, 3},
+	{"LongLeftRightArrow", "\xE2\x9F\xB7", 18, 3},
+	{"LongRightArrow", "\xE2\x9F\xB6", 14, 3},
+	{"Longleftarrow", "\xE2\x9F\xB8", 13, 3},
+	{"Longleftrightarrow", "\xE2\x9F\xBA", 18, 3},
+	{"Longrightarrow", "\xE2\x9F\xB9", 14, 3},
+	{"Lopf", "\xF0\x9D\x95\x83", 4, 4},
+	{"LowerLeftArrow", "\xE2\x86\x99", 14, 3},
+	{"LowerRightArrow", "\xE2\x86\x98", 15, 3},
+	{"Lscr", "\xE2\x84\x92", 4, 3},
+	{"Lsh", "\xE2\x86\xB0", 3, 3},
+	{"Lstrok", "\xC5\x81", 6, 2},
+	{"Lt", "\xE2\x89\xAA", 2, 3},
+	{"Map", "\xE2\xA4\x85", 3, 3},
+	{"Mcy", "\xD0\x9C", 3, 2},
+	{"MediumSpace", "\xE2\x81\x9F", 11, 3},
+	{"Mellintrf", "\xE2\x84\xB3", 9, 3},
+	{"Mfr", "\xF0\x9D\x94\x90", 3, 4},
+	{"MinusPlus", "\xE2\x88\x93", 9, 3},
+	{"Mopf", "\xF0\x9D\x95\x84", 4, 4},
+	{"Mscr", "\xE2\x84\xB3", 4, 3},
+	{"Mu", "\xCE\x9C", 2, 2},
+	{"NJcy", "\xD0\x8A", 4, 2},
+	{"Nacute", "\xC5\x83", 6, 2},
+	{"Ncaron", "\xC5\x87", 6, 2},
+	{"Ncedil", "\xC5\x85", 6, 2},
+	{"Ncy", "\xD0\x9D", 3, 2},
+	{"NegativeMediumSpace", "\xE2\x80\x8B", 19, 3},
+	{"NegativeThickSpace", "\xE2\x80\x8B", 18, 3},
+	{"NegativeThinSpace", "\xE2\x80\x8B", 17, 3},
+	{"NegativeVeryThinSpace", "\xE2\x80\x8B", 21, 3},
+	{"NestedGreaterGreater", "\xE2\x89\xAB", 20, 3},
+	{"NestedLessLess", "\xE2\x89\xAA", 14, 3},
+	{"NewLine", "\x0A", 7, 1},
+	{"Nfr", "\xF0\x9D\x94\x91", 3, 4},
+	{"NoBreak", "\xE2\x81\xA0", 7, 3},
+	{"NonBreakingSpace", "\xC2\xA0", 16, 2},
+	{"Nopf", "\xE2\x84\x95", 4, 3},
+	{"Not", "\xE2\xAB\xAC", 3, 3},
+	{"NotCongruent", "\xE2\x89\xA2", 12, 3},
+	{"NotCupCap", "\xE2\x89\xAD", 9, 3},
+	{"NotDoubleVerticalBar", "\xE2\x88\xA6", 20, 3},
+	{"NotElement", "\xE2\x88\x89", 10, 3},
+	{"NotEqual", "\xE2\x89\xA0", 8, 3},
+	{"NotEqualTilde", "\xE2\x89\x82\xCC\xB8", 13, 5},
+	{"NotExists", "\xE2\x88\x84", 9, 3},
+	{"NotGreater", "\xE2\x89\xAF", 10, 3},
+	{"NotGreaterEqual", "\xE2\x89\xB1", 15, 3},
+	{"NotGreaterFullEqual", "\xE2\x89\xA7\xCC\xB8", 19, 5},
+	{"NotGreaterGreater", "\xE2\x89\xAB\xCC\xB8", 17, 5},
+	{"NotGreaterLess", "\xE2\x89\xB9", 14, 3},
+	{"NotGreaterSlantEqual", "\xE2\xA9\xBE\xCC\xB8", 20, 5},
+	{"NotGreaterTilde", "\xE2\x89\xB5", 15, 3},
+	{"NotHumpDownHump", "\xE2\x89\x8E\xCC\xB8", 15, 5},
+	{"NotHumpEqual", "\xE2\x89\x8F\xCC\xB8", 12, 5},
+	{"NotLeftTriangle", "\xE2\x8B\xAA", 15, 3},
+	{"NotLeftTriangleBar", "\xE2\xA7\x8F\xCC\xB8", 18, 5},
+	{"NotLeftTriangleEqual", "\xE2\x8B\xAC", 20, 3},
+	{"NotLess", "\xE2\x89\xAE", 7, 3},
+	{"NotLessEqual", "\xE2\x89\xB0", 12, 3},
+	{"NotLessGreater", "\xE2\x89\xB8", 14, 3},
+	{"NotLessLess", "\xE2\x89\xAA\xCC\xB8", 11, 5},
+	{"NotLessSlantEqual", "\xE2\xA9\xBD\xCC\xB8", 17, 5},
+	{"NotLessTilde", "\xE2\x89\xB4", 12, 3},
+	{"NotNestedGreaterGreater", "\xE2\xAA\xA2\xCC\xB8", 23, 5},
+	{"NotNestedLessLess", "\xE2\xAA\xA1\xCC\xB8", 17, 5},
+	{"NotPrecedes", "\xE2\x8A\x80", 11, 3},
+	{"NotPrecedesEqual", "\xE2\xAA\xAF\xCC\xB8", 16, 5},
+	{"NotPrecedesSlantEqual", "\xE2\x8B\xA0", 21, 3},
+	{"NotReverseElement", "\xE2\x88\x8C", 17, 3},
+	{"NotRightTriangle", "\xE2\x8B\xAB", 16, 3},
+	{"NotRightTriangleBar", "\xE2\xA7\x90\xCC\xB8", 19, 5},
+	{"NotRightTriangleEqual", "\xE2\x8B\xAD", 21, 3},
+	{"NotSquareSubset", "\xE2\x8A\x8F\xCC\xB8", 15, 5},
+	{"NotSquareSubsetEqual", "\xE2\x8B\xA2", 20, 3},
+	{"NotSquareSuperset", "\xE2\x8A\x90\xCC\xB8", 17, 5},
+	{"NotSquareSupersetEqual", "\xE2\x8B\xA3", 22, 3},
+	{"NotSubset", "\xE2\x8A\x82\xE2\x83\x92", 9, 6},
+	{"NotSubsetEqual", "\xE2\x8A\x88", 14, 3},
+	{"NotSucceeds", "\xE2\x8A\x81", 11, 3},
+	{"NotSucceedsEqual", "\xE2\xAA\xB0\xCC\xB8", 16, 5},
+	{"NotSucceedsSlantEqual", "\xE2\x8B\xA1", 21, 3},
+	{"NotSucceedsTilde", "\xE2\x89\xBF\xCC\xB8", 16, 5},
+	{"NotSuperset", "\xE2\x8A\x83\xE2\x83\x92", 11, 6},
+	{"NotSupersetEqual", "\xE2\x8A\x89", 16, 3},
+	{"NotTilde", "\xE2\x89\x81", 8, 3},
+	{"NotTildeEqual", "\xE2\x89\x84", 13, 3},
+	{"NotTildeFullEqual", "\xE2\x89\x87", 17, 3},
+	{"NotTildeTilde", "\xE2\x89\x89", 13, 3},
+	{"NotVerticalBar", "\xE2\x88\xA4", 14, 3},
+	{"Nscr", "\xF0\x9D\x92\xA9", 4, 4},
+	{"Ntilde", "\xC3\x91", 6, 2},
+	{"Nu", "\xCE\x9D", 2, 2},
+	{"OElig", "\xC5\x92", 5, 2},
+	{"Oacute", "\xC3\x93", 6, 2},
+	{"Ocirc", "\xC3\x94", 5, 2},
+	{"Ocy", "\xD0\x9E", 3, 2},
+	{"Odblac", "\xC5\x90", 6, 2},
+	{"Ofr", "\xF0\x9D\x94\x92", 3, 4},
+	{"Ograve", "\xC3\x92", 6, 2},
+	{"Omacr", "\xC5\x8C", 5, 2},
+	{"Omega", "\xCE\xA9", 5, 2},
+	{"Omicron", "\xCE\x9F", 7, 2},
+	{"Oopf", "\xF0\x9D\x95\x86", 4, 4},
+	{"OpenCurlyDoubleQuote", "\xE2\x80\x9C", 20, 3},
+	{"OpenCurlyQuote", "\xE2\x80\x98", 14, 3},
+	{"Or", "\xE2\xA9\x94", 2, 3},
+	{"Oscr", "\xF0\x9D\x92\xAA", 4, 4},
+	{"Oslash", "\xC3\x98", 6, 2},
+	{"Otilde", "\xC3\x95", 6, 2},
+	{"Otimes", "\xE2\xA8\xB7", 6, 3},
+	{"Ouml", "\xC3\x96", 4, 2},
+	{"OverBar", "\xE2\x80\xBE", 7, 3},
+	{"OverBrace", "\xE2\x8F\x9E", 9, 3},
+	{"OverBracket", "\xE2\x8E\xB4", 11, 3},
+	{"OverParenthesis", "\xE2\x8F\x9C", 15, 3},
+	{"PartialD", "\xE2\x88\x82", 8, 3},
+	{"Pcy", "\xD0\x9F", 3, 2},
+	{"Pfr", "\xF0\x9D\x94\x93", 3, 4},
+	{"Phi", "\xCE\xA6", 3, 2},
+	{"Pi", "\xCE\xA0", 2, 2},
+	{"PlusMinus", "\xC2\xB1", 9, 2},
+	{"Poincareplane", "\xE2\x84\x8C", 13, 3},
+	{"Popf", "\xE2\x84\x99", 4, 3},
+	{"Pr", "\xE2\xAA\xBB", 2, 3},
+	{"Precedes", "\xE2\x89\xBA", 8, 3},
+	{"PrecedesEqual", "\xE2\xAA\xAF", 13, 3},
+	{"PrecedesSlantEqual", "\xE2\x89\xBC", 18, 3},
+	{"PrecedesTilde", "\xE2\x89\xBE", 13, 3},
+	{"Prime", "\xE2\x80\xB3", 5, 3},
+	{"Product", "\xE2\x88\x8F", 7, 3},
+	{"Proportion", "\xE2\x88\xB7", 10, 3},
+	{"Proportional", "\xE2\x88\x9D", 12, 3},
+	{"Pscr", "\xF0\x9D\x92\xAB", 4, 4},
+	{"Psi", "\xCE\xA8", 3, 2},
+	{"QUOT", "\x22", 4, 1},
+	{"Qfr", "\xF0\x9D\x94\x94", 3, 4},
+	{"Qopf", "\xE2\x84\x9A", 4, 3},
+	{"Qscr", "\xF0\x9D\x92\xAC", 4, 4},
+	{"RBarr", "\xE2\xA4\x90", 5, 3},
+	{"REG", "\xC2\xAE", 3, 2},
+	{"Racute", "\xC5\x94", 6, 2},
+	{"Rang", "\xE2\x9F\xAB", 4, 3},
+	{"Rarr", "\xE2\x86\xA0", 4, 3},
+	{"Rarrtl", "\xE2\xA4\x96", 6, 3},
+	{"Rcaron", "\xC5\x98", 6, 2},
+	{"Rcedil", "\xC5\x96", 6, 2},
+	{"Rcy", "\xD0\xA0", 3, 2},
+	{"Re", "\xE2\x84\x9C", 2, 3},
+	{"ReverseElement", "\xE2\x88\x8B", 14, 3},
+	{"ReverseEquilibrium", "\xE2\x87\x8B", 18, 3},
+	{"ReverseUpEquilibrium", "\xE2\xA5\xAF", 20, 3},
+	{"Rfr", "\xE2\x84\x9C", 3, 3},
+	{"Rho", "\xCE\xA1", 3, 2},
+	{"RightAngleBracket", "\xE2\x9F\xA9", 17, 3},
+	{"RightArrow", "\xE2\x86\x92", 10, 3},
+	{"RightArrowBar", "\xE2\x87\xA5", 13, 3},
+	{"RightArrowLeftArrow", "\xE2\x87\x84", 19, 3},
+	{"RightCeiling", "\xE2\x8C\x89", 12, 3},
+	{"RightDoubleBracket", "\xE2\x9F\xA7", 18, 3},
+	{"RightDownTeeVector", "\xE2\xA5\x9D", 18, 3},
+	{"RightDownVector", "\xE2\x87\x82", 15, 3},
+	{"RightDownVectorBar", "\xE2\xA5\x95", 18, 3},
+	{"RightFloor", "\xE2\x8C\x8B", 10, 3},
+	{"RightTee", "\xE2\x8A\xA2", 8, 3},
+	{"RightTeeArrow", "\xE2\x86\xA6", 13, 3},
+	{"RightTeeVector", "\xE2\xA5\x9B", 14, 3},
+	{"RightTriangle", "\xE2\x8A\xB3", 13, 3},
+	{"RightTriangleBar", "\xE2\xA7\x90", 16, 3},
+	{"RightTriangleEqual", "\xE2\x8A\xB5", 18, 3},
+	{"RightUpDownVector", "\xE2\xA5\x8F", 17, 3},
+	{"RightUpTeeVector", "\xE2\xA5\x9C", 16, 3},
+	{"RightUpVector", "\xE2\x86\xBE", 13, 3},
+	{"RightUpVectorBar", "\xE2\xA5\x94", 16, 3},
+	{"RightVector", "\xE2\x87\x80", 11, 3},
+	{"RightVectorBar", "\xE2\xA5\x93", 14, 3},
+	{"Rightarrow", "\xE2\x87\x92", 10, 3},
+	{"Ropf", "\xE2\x84\x9D", 4, 3},
+	{"RoundImplies", "\xE2\xA5\xB0", 12, 3},
+	{"Rrightarrow", "\xE2\x87\x9B", 11, 3},
+	{"Rscr", "\xE2\x84\x9B", 4, 3},
+	{"Rsh", "\xE2\x86\xB1", 3, 3},
+	{"RuleDelayed", "\xE2\xA7\xB4", 11, 3},
+	{"SHCHcy", "\xD0\xA9", 6, 2},
+	{"SHcy", "\xD0\xA8", 4, 2},
+	{"SOFTcy", "\xD0\xAC", 6, 2},
+	{"Sacute", "\xC5\x9A", 6, 2},
+	{"Sc", "\xE2\xAA\xBC", 2, 3},
+	{"Scaron", "\xC5\xA0", 6, 2},
+	{"Scedil", "\xC5\x9E", 6, 2},
+	{"Scirc", "\xC5\x9C", 5, 2},
+	{"Scy", "\xD0\xA1", 3, 2},
+	{"Sfr", "\xF0\x9D\x94\x96", 3, 4},
+	{"ShortDownArrow", "\xE2\x86\x93", 14, 3},
+	{"ShortLeftArrow", "\xE2\x86\x90", 14, 3},
+	{"ShortRightArrow", "\xE2\x86\x92", 15, 3},
+	{"ShortUpArrow", "\xE2\x86\x91", 12, 3},
+	{"Sigma", "\xCE\xA3", 5, 2},
+	{"SmallCircle", "\xE2\x88\x98", 11, 3},
+	{"Sopf", "\xF0\x9D\x95\x8A", 4, 4},
+	{"Sqrt", "\xE2\x88\x9A", 4, 3},
+	{"Square", "\xE2\x96\xA1", 6, 3},
+	{"SquareIntersection", "\xE2\x8A\x93", 18, 3},
+	{"SquareSubset", "\xE2\x8A\x8F", 12, 3},
+	{"SquareSubsetEqual", "\xE2\x8A\x91", 17, 3},
+	{"SquareSuperset", "\xE2\x8A\x90", 14, 3},
+	{"SquareSupersetEqual", "\xE2\x8A\x92", 19, 3},
+	{"SquareUnion", "\xE2\x8A\x94", 11, 3},
+	{"Sscr", "\xF0\x9D\x92\xAE", 4, 4},
+	{"Star", "\xE2\x8B\x86", 4, 3},
+	{"Sub", "\xE2\x8B\x90", 3, 3},
+	{"Subset", "\xE2\x8B\x90", 6, 3},
+	{"SubsetEqual", "\xE2\x8A\x86", 11, 3},
+	{"Succeeds", "\xE2\x89\xBB", 8, 3},
+	{"SucceedsEqual", "\xE2\xAA\xB0", 13, 3},
+	{"SucceedsSlantEqual", "\xE2\x89\xBD", 18, 3},
+	{"SucceedsTilde", "\xE2\x89\xBF", 13, 3},
+	{"SuchThat", "\xE2\x88\x8B", 8, 3},
+	{"Sum", "\xE2\x88\x91", 3, 3},
+	{"Sup", "\xE2\x8B\x91", 3, 3},
+	{"Superset", "\xE2\x8A\x83", 8, 3},
+	{"SupersetEqual", "\xE2\x8A\x87", 13, 3},
+	{"Supset", "\xE2\x8B\x91", 6, 3},
+	{"THORN", "\xC3\x9E", 5, 2},
+	{"TRADE", "\xE2\x84\xA2", 5, 3},
+	{"TSHcy", "\xD0\x8B", 5, 2},
+	{"TScy", "\xD0\xA6", 4, 2},
+	{"Tab", "\x09", 3, 1},
+	{"Tau", "\xCE\xA4", 3, 2},
+	{"Tcaron", "\xC5\xA4", 6, 2},
+	{"Tcedil", "\xC5\xA2", 6, 2},
+	{"Tcy", "\xD0\xA2", 3, 2},
+	{"Tfr", "\xF0\x9D\x94\x97", 3, 4},
+	{"Therefore", "\xE2\x88\xB4", 9, 3},
+	{"Theta", "\xCE\x98", 5, 2},
+	{"ThickSpace", "\xE2\x81\x9F\xE2\x80\x8A", 10, 6},
+	{"ThinSpace", "\xE2\x80\x89", 9, 3},
+	{"Tilde", "\xE2\x88\xBC", 5, 3},
+	{"TildeEqual", "\xE2\x89\x83", 10, 3},
+	{"TildeFullEqual", "\xE2\x89\x85", 14, 3},
+	{"TildeTilde", "\xE2\x89\x88", 10, 3},
+	{"Topf", "\xF0\x9D\x95\x8B", 4, 4},
+	{"TripleDot", "\xE2\x83\x9B", 9, 3},
+	{"Tscr", "\xF0\x9D\x92\xAF", 4, 4},
+	{"Tstrok", "\xC5\xA6", 6, 2},
+	{"Uacute", "\xC3\x9A", 6, 2},
+	{"Uarr", "\xE2\x86\x9F", 4, 3},
+	{"Uarrocir", "\xE2\xA5\x89", 8, 3},
+	{"Ubrcy", "\xD0\x8E", 5, 2},
+	{"Ubreve", "\xC5\xAC", 6, 2},
+	{"Ucirc", "\xC3\x9B", 5, 2},
+	{"Ucy", "\xD0\xA3", 3, 2},
+	{"Udblac", "\xC5\xB0", 6, 2},
+	{"Ufr", "\xF0\x9D\x94\x98", 3, 4},
+	{"Ugrave", "\xC3\x99", 6, 2},
+	{"Umacr", "\xC5\xAA", 5, 2},
+	{"UnderBar", "\x5F", 8, 1},
+	{"UnderBrace", "\xE2\x8F\x9F", 10, 3},
+	{"UnderBracket", "\xE2\x8E\xB5", 12, 3},
+	{"UnderParenthesis", "\xE2\x8F\x9D", 16, 3},
+	{"Union", "\xE2\x8B\x83", 5, 3},
+	{"UnionPlus", "\xE2\x8A\x8E", 9, 3},
+	{"Uogon", "\xC5\xB2", 5, 2},
+	{"Uopf", "\xF0\x9D\x95\x8C", 4, 4},
+	{"UpArrow", "\xE2\x86\x91", 7, 3},
+	{"UpArrowBar", "\xE2\xA4\x92", 10, 3},
+	{"UpArrowDownArrow", "\xE2\x87\x85", 16, 3},
+	{"UpDownArrow", "\xE2\x86\x95", 11, 3},
+	{"UpEquilibrium", "\xE2\xA5\xAE", 13, 3},
+	{"UpTee", "\xE2\x8A\xA5", 5, 3},
+	{"UpTeeArrow", "\xE2\x86\xA5", 10, 3},
+	{"Uparrow", "\xE2\x87\x91", 7, 3},
+	{"Updownarrow", "\xE2\x87\x95", 11, 3},
+	{"UpperLeftArrow", "\xE2\x86\x96", 14, 3},
+	{"UpperRightArrow", "\xE2\x86\x97", 15, 3},
+	{"Upsi", "\xCF\x92", 4, 2},
+	{"Upsilon", "\xCE\xA5", 7, 2},
+	{"Uring", "\xC5\xAE", 5, 2},
+	{"Uscr", "\xF0\x9D\x92\xB0", 4, 4},
+	{"Utilde", "\xC5\xA8", 6, 2},
+	{"Uuml", "\xC3\x9C", 4, 2},
+	{"VDash", "\xE2\x8A\xAB", 5, 3},
+	{"Vbar", "\xE2\xAB\xAB", 4, 3},
+	{"Vcy", "\xD0\x92", 3, 2},
+	{"Vdash", "\xE2\x8A\xA9", 5, 3},
+	{"Vdashl", "\xE2\xAB\xA6", 6, 3},
+	{"Vee", "\xE2\x8B\x81", 3, 3},
+	{"Verbar", "\xE2\x80\x96", 6, 3},
+	{"Vert", "\xE2\x80\x96", 4, 3},
+	{"VerticalBar", "\xE2\x88\xA3", 11, 3},
+	{"VerticalLine", "\x7C", 12, 1},
+	{"VerticalSeparator", "\xE2\x9D\x98", 17, 3},
+	{"VerticalTilde", "\xE2\x89\x80", 13, 3},
+	{"VeryThinSpace", "\xE2\x80\x8A", 13, 3},
+	{"Vfr", "\xF0\x9D\x94\x99", 3, 4},
+	{"Vopf", "\xF0\x9D\x95\x8D", 4, 4},
+	{"Vscr", "\xF0\x9D\x92\xB1", 4, 4},
+	{"Vvdash", "\xE2\x8A\xAA", 6, 3},
+	{"Wcirc", "\xC5\xB4", 5, 2},
+	{"Wedge", "\xE2\x8B\x80", 5, 3},
+	{"Wfr", "\xF0\x9D\x94\x9A", 3, 4},
+	{"Wopf", "\xF0\x9D\x95\x8E", 4, 4},
+	{"Wscr", "\xF0\x9D\x92\xB2", 4, 4},
+	{"Xfr", "\xF0\x9D\x94\x9B", 3, 4},
+	{"Xi", "\xCE\x9E", 2, 2},
+	{"Xopf", "\xF0\x9D\x95\x8F", 4, 4},
+	{"Xscr", "\xF0\x9D\x92\xB3", 4, 4},
+	{"YAcy", "\xD0\xAF", 4, 2},
+	{"YIcy", "\xD0\x87", 4, 2},
+	{"YUcy", "\xD0\xAE", 4, 2},
+	{"Yacute", "\xC3\x9D", 6, 2},
+	{"Ycirc", "\xC5\xB6", 5, 2},
+	{"Ycy", "\xD0\xAB", 3, 2},
+	{"Yfr", "\xF0\x9D\x94\x9C", 3, 4},
+	{"Yopf", "\xF0\x9D\x95\x90", 4, 4},
+	{"Yscr", "\xF0\x9D\x92\xB4", 4, 4},
+	{"Yuml", "\xC5\xB8", 4, 2},
+	{"ZHcy", "\xD0\x96", 4, 2},
+	{"Zacute", "\xC5\xB9", 6, 2},
+	{"Zcaron", "\xC5\xBD", 6, 2},
+	{"Zcy", "\xD0\x97", 3, 2},
+	{"Zdot", "\xC5\xBB", 4, 2},
+	{"ZeroWidthSpace", "\xE2\x80\x8B", 14, 3},
+	{"Zeta", "\xCE\x96", 4, 2},
+	{"Zfr", "\xE2\x84\xA8", 3, 3},
+	{"Zopf", "\xE2\x84\xA4", 4, 3},
+	{"Zscr", "\xF0\x9D\x92\xB5", 4, 4},
+	{"aacute", "\xC3\xA1", 6, 2},
+	{"abreve", "\xC4\x83", 6, 2},
+	{"ac", "\xE2\x88\xBE", 2, 3},
+	{"acE", "\xE2\x88\xBE\xCC\xB3", 3, 5},
+	{"acd", "\xE2\x88\xBF", 3, 3},
+	{"acirc", "\xC3\xA2", 5, 2},
+	{"acute", "\xC2\xB4", 5, 2},
+	{"acy", "\xD0\xB0", 3, 2},
+	{"aelig", "\xC3\xA6", 5, 2},
+	{"af", "\xE2\x81\xA1", 2, 3},
+	{"afr", "\xF0\x9D\x94\x9E", 3, 4},
+	{"agrave", "\xC3\xA0", 6, 2},
+	{"alefsym", "\xE2\x84\xB5", 7, 3},
+	{"aleph", "\xE2\x84\xB5", 5, 3},
+	{"alpha", "\xCE\xB1", 5, 2},
+	{"amacr", "\xC4\x81", 5, 2},
+	{"amalg", "\xE2\xA8\xBF", 5, 3},
+	{"amp", "\x26", 3, 1},
+	{"and", "\xE2\x88\xA7", 3, 3},
+	{"andand", "\xE2\xA9\x95", 6, 3},
+	{"andd", "\xE2\xA9\x9C", 4, 3},
+	{"andslope", "\xE2\xA9\x98", 8, 3},
+	{"andv", "\xE2\xA9\x9A", 4, 3},
+	{"ang", "\xE2\x88\xA0", 3, 3},
+	{"ange", "\xE2\xA6\xA4", 4, 3},
+	{"angle", "\xE2\x88\xA0", 5, 3},
+	{"angmsd", "\xE2\x88\xA1", 6, 3},
+	{"angmsdaa", "\xE2\xA6\xA8", 8, 3},
+	{"angmsdab", "\xE2\xA6\xA9", 8, 3},
+	{"angmsdac", "\xE2\xA6\xAA", 8, 3},
+	{"angmsdad", "\xE2\xA6\xAB", 8, 3},
+	{"angmsdae", "\xE2\xA6\xAC", 8, 3},
+	{"angmsdaf", "\xE2\xA6\xAD", 8, 3},
+	{"angmsdag", "\xE2\xA6\xAE", 8, 3},
+	{"angmsdah", "\xE2\xA6\xAF", 8, 3},
+	{"angrt", "\xE2\x88\x9F", 5, 3},
+	{"angrtvb", "\xE2\x8A\xBE", 7, 3},
+	{"angrtvbd", "\xE2\xA6\x9D", 8, 3},
+	{"angsph", "\xE2\x88\xA2", 6, 3},
+	{"angst", "\xC3\x85", 5, 2},
+	{"angzarr", "\xE2\x8D\xBC", 7, 3},
+	{"aogon", "\xC4\x85", 5, 2},
+	{"aopf", "\xF0\x9D\x95\x92", 4, 4},
+	{"ap", "\xE2\x89\x88", 2, 3},
+	{"apE", "\xE2\xA9\xB0", 3, 3},
+	{"apacir", "\xE2\xA9\xAF", 6, 3},
+	{"ape", "\xE2\x89\x8A", 3, 3},
+	{"apid", "\xE2\x89\x8B", 4, 3},
+	{"apos", "\x27", 4, 1},
+	{"approx", "\xE2\x89\x88", 6, 3},
+	{"approxeq", "\xE2\x89\x8A", 8, 3},
+	{"aring", "\xC3\xA5", 5, 2},
+	{"ascr", "\xF0\x9D\x92\xB6", 4, 4},
+	{"ast", "\x2A", 3, 1},
+	{"asymp", "\xE2\x89\x88", 5, 3},
+	{"asympeq", "\xE2\x89\x8D", 7, 3},
+	{"atilde", "\xC3\xA3", 6, 2},
+	{"auml", "\xC3\xA4", 4, 2},
+	{"awconint", "\xE2\x88\xB3", 8, 3},
+	{"awint", "\xE2\xA8\x91", 5, 3},
+	{"bNot", "\xE2\xAB\xAD", 4, 3},
+	{"backcong", "\xE2\x89\x8C", 8, 3},
+	{"backepsilon", "\xCF\xB6", 11, 2},
+	{"backprime", "\xE2\x80\xB5", 9, 3},
+	{"backsim", "\xE2\x88\xBD", 7, 3},
+	{"backsimeq", "\xE2\x8B\x8D", 9, 3},
+	{"barvee", "\xE2\x8A\xBD", 6, 3},
+	{"barwed", "\xE2\x8C\x85", 6, 3},
+	{"barwedge", "\xE2\x8C\x85", 8, 3},
+	{"bbrk", "\xE2\x8E\xB5", 4, 3},
+	{"bbrktbrk", "\xE2\x8E\xB6", 8, 3},
+	{"bcong", "\xE2\x89\x8C", 5, 3},
+	{"bcy", "\xD0\xB1", 3, 2},
+	{"bdquo", "\xE2\x80\x9E", 5, 3},
+	{"becaus", "\xE2\x88\xB5", 6, 3},
+	{"because", "\xE2\x88\xB5", 7, 3},
+	{"bemptyv", "\xE2\xA6\xB0", 7, 3},
+	{"bepsi", "\xCF\xB6", 5, 2},
+	{"bernou", "\xE2\x84\xAC", 6, 3},
+	{"beta", "\xCE\xB2", 4, 2},
+	{"beth", "\xE2\x84\xB6", 4, 3},
+	{"between", "\xE2\x89\xAC", 7, 3},
+	{"bfr", "\xF0\x9D\x94\x9F", 3, 4},
+	{"bigcap", "\xE2\x8B\x82", 6, 3},
+	{"bigcirc", "\xE2\x97\xAF", 7, 3},
+	{"bigcup", "\xE2\x8B\x83", 6, 3},
+	{"bigodot", "\xE2\xA8\x80", 7, 3},
+	{"bigoplus", "\xE2\xA8\x81", 8, 3},
+	{"bigotimes", "\xE2\xA8\x82", 9, 3},
+	{"bigsqcup", "\xE2\xA8\x86", 8, 3},
+	{"bigstar", "\xE2\x98\x85", 7, 3},
+	{"bigtriangledown", "\xE2\x96\xBD", 15, 3},
+	{"bigtriangleup", "\xE2\x96\xB3", 13, 3},
+	{"biguplus", "\xE2\xA8\x84", 8, 3},
+	{"bigvee", "\xE2\x8B\x81", 6, 3},
+	{"bigwedge", "\xE2\x8B\x80", 8, 3},
+	{"bkarow", "\xE2\xA4\x8D", 6, 3},
+	{"blacklozenge", "\xE2\xA7\xAB", 12, 3},
+	{"blacksquare", "\xE2\x96\xAA", 11, 3},
+	{"blacktriangle", "\xE2\x96\xB4", 13, 3},
+	{"blacktriangledown", "\xE2\x96\xBE", 17, 3},
+	{"blacktriangleleft", "\xE2\x97\x82", 17, 3},
+	{"blacktriangleright", "\xE2\x96\xB8", 18, 3},
+	{"blank", "\xE2\x90\xA3", 5, 3},
+	{"blk12", "\xE2\x96\x92", 5, 3},
+	{"blk14", "\xE2\x96\x91", 5, 3},
+	{"blk34", "\xE2\x96\x93", 5, 3},
+	{"block", "\xE2\x96\x88", 5, 3},
+	{"bne", "\x3D\xE2\x83\xA5", 3, 4},
+	{"bnequiv", "\xE2\x89\xA1\xE2\x83\xA5", 7, 6},
+	{"bnot", "\xE2\x8C\x90", 4, 3},
+	{"bopf", "\xF0\x9D\x95\x93", 4, 4},
+	{"bot", "\xE2\x8A\xA5", 3, 3},
+	{"bottom", "\xE2\x8A\xA5", 6, 3},
+	{"bowtie", "\xE2\x8B\x88", 6, 3},
+	{"boxDL", "\xE2\x95\x97", 5, 3},
+	{"boxDR", "\xE2\x95\x94", 5, 3},
+	{"boxDl", "\xE2\x95\x96", 5, 3},
+	{"boxDr", "\xE2\x95\x93", 5, 3},
+	{"boxH", "\xE2\x95\x90", 4, 3},
+	{"boxHD", "\xE2\x95\xA6", 5, 3},
+	{"boxHU", "\xE2\x95\xA9", 5, 3},
+	{"boxHd", "\xE2\x95\xA4", 5, 3},
+	{"boxHu", "\xE2\x95\xA7", 5, 3},
+	{"boxUL", "\xE2\x95\x9D", 5, 3},
+	{"boxUR", "\xE2\x95\x9A", 5, 3},
+	{"boxUl", "\xE2\x95\x9C", 5, 3},
+	{"boxUr", "\xE2\x95\x99", 5, 3},
+	{"boxV", "\xE2\x95\x91", 4, 3},
+	{"boxVH", "\xE2\x95\xAC", 5, 3},
+	{"boxVL", "\xE2\x95\xA3", 5, 3},
+	{"boxVR", "\xE2\x95\xA0", 5, 3},
+	{"boxVh", "\xE2\x95\xAB", 5, 3},
+	{"boxVl", "\xE2\x95\xA2", 5, 3},
+	{"boxVr", "\xE2\x95\x9F", 5, 3},
+	{"boxbox", "\xE2\xA7\x89", 6, 3},
+	{"boxdL", "\xE2\x95\x95", 5, 3},
+	{"boxdR", "\xE2\x95\x92", 5, 3},
+	{"boxdl", "\xE2\x94\x90", 5, 3},
+	{"boxdr", "\xE2\x94\x8C", 5, 3},
+	{"boxh", "\xE2\x94\x80", 4, 3},
+	{"boxhD", "\xE2\x95\xA5", 5, 3},
+	{"boxhU", "\xE2\x95\xA8", 5, 3},
+	{"boxhd", "\xE2\x94\xAC", 5, 3},
+	{"boxhu", "\xE2\x94\xB4", 5, 3},
+	{"boxminus", "\xE2\x8A\x9F", 8, 3},
+	{"boxplus", "\xE2\x8A\x9E", 7, 3},
+	{"boxtimes", "\xE2\x8A\xA0", 8, 3},
+	{"boxuL", "\xE2\x95\x9B", 5, 3},
+	{"boxuR", "\xE2\x95\x98", 5, 3},
+	{"boxul", "\xE2\x94\x98", 5, 3},
+	{"boxur", "\xE2\x94\x94", 5, 3},
+	{"boxv", "\xE2\x94\x82", 4, 3},
+	{"boxvH", "\xE2\x95\xAA", 5, 3},
+	{"boxvL", "\xE2\x95\xA1", 5, 3},
+	{"boxvR", "\xE2\x95\x9E", 5, 3},
+	{"boxvh", "\xE2\x94\xBC", 5, 3},
+	{"boxvl", "\xE2\x94\xA4", 5, 3},
+	{"boxvr", "\xE2\x94\x9C", 5, 3},
+	{"bprime", "\xE2\x80\xB5", 6, 3},
+	{"breve", "\xCB\x98", 5, 2},
+	{"brvbar", "\xC2\xA6", 6, 2},
+	{"bscr", "\xF0\x9D\x92\xB7", 4, 4},
+	{"bsemi", "\xE2\x81\x8F", 5, 3},
+	{"bsim", "\xE2\x88\xBD", 4, 3},
+	{"bsime", "\xE2\x8B\x8D", 5, 3},
+	{"bsol", "\x5C", 4, 1},
+	{"bsolb", "\xE2\xA7\x85", 5, 3},
+	{"bsolhsub", "\xE2\x9F\x88", 8, 3},
+	{"bull", "\xE2\x80\xA2", 4, 3},
+	{"bullet", "\xE2\x80\xA2", 6, 3},
+	{"bump", "\xE2\x89\x8E", 4, 3},
+	{"bumpE", "\xE2\xAA\xAE", 5, 3},
+	{"bumpe", "\xE2\x89\x8F", 5, 3},
+	{"bumpeq", "\xE2\x89\x8F", 6, 3},
+	{"cacute", "\xC4\x87", 6, 2},
+	{"cap", "\xE2\x88\xA9", 3, 3},
+	{"capand", "\xE2\xA9\x84", 6, 3},
+	{"capbrcup", "\xE2\xA9\x89", 8, 3},
+	{"capcap", "\xE2\xA9\x8B", 6, 3},
+	{"capcup", "\xE2\xA9\x87", 6, 3},
+	{"capdot", "\xE2\xA9\x80", 6, 3},
+	{"caps", "\xE2\x88\xA9\xEF\xB8\x80", 4, 6},
+	{"caret", "\xE2\x81\x81", 5, 3},
+	{"caron", "\xCB\x87", 5, 2},
+	{"ccaps", "\xE2\xA9\x8D", 5, 3},
+	{"ccaron", "\xC4\x8D", 6, 2},
+	{"ccedil", "\xC3\xA7", 6, 2},
+	{"ccirc", "\xC4\x89", 5, 2},
+	{"ccups", "\xE2\xA9\x8C", 5, 3},
+	{"ccupssm", "\xE2\xA9\x90", 7, 3},
+	{"cdot", "\xC4\x8B", 4, 2},
+	{"cedil", "\xC2\xB8", 5, 2},
+	{"cemptyv", "\xE2\xA6\xB2", 7, 3},
+	{"cent", "\xC2\xA2", 4, 2},
+	{"centerdot", "\xC2\xB7", 9, 2},
+	{"cfr", "\xF0\x9D\x94\xA0", 3, 4},
+	{"chcy", "\xD1\x87", 4, 2},
+	{"check", "\xE2\x9C\x93", 5, 3},
+	{"checkmark", "\xE2\x9C\x93", 9, 3},
+	{"chi", "\xCF\x87", 3, 2},
+	{"cir", "\xE2\x97\x8B", 3, 3},
+	{"cirE", "\xE2\xA7\x83", 4, 3},
+	{"circ", "\xCB\x86", 4, 2},
+	{"circeq", "\xE2\x89\x97", 6, 3},
+	{"circlearrowleft", "\xE2\x86\xBA", 15, 3},
+	{"circlearrowright", "\xE2\x86\xBB", 16, 3},
+	{"circledR", "\xC2\xAE", 8, 2},
+	{"circledS", "\xE2\x93\x88", 8, 3},
+	{"circledast", "\xE2\x8A\x9B", 10, 3},
+	{"circledcirc", "\xE2\x8A\x9A", 11, 3},
+	{"circleddash", "\xE2\x8A\x9D", 11, 3},
+	{"cire", "\xE2\x89\x97", 4, 3},
+	{"cirfnint", "\xE2\xA8\x90", 8, 3},
+	{"cirmid", "\xE2\xAB\xAF", 6, 3},
+	{"cirscir", "\xE2\xA7\x82", 7, 3},
+	{"clubs", "\xE2\x99\xA3", 5, 3},
+	{"clubsuit", "\xE2\x99\xA3", 8, 3},
+	{"colon", "\x3A", 5, 1},
+	{"colone", "\xE2\x89\x94", 6, 3},
+	{"coloneq", "\xE2\x89\x94", 7, 3},
+	{"comma", "\x2C", 5, 1},
+	{"commat", "\x40", 6, 1},
+	{"comp", "\xE2\x88\x81", 4, 3},
+	{"compfn", "\xE2\x88\x98", 6, 3},
+	{"complement", "\xE2\x88\x81", 10, 3},
+	{"complexes", "\xE2\x84\x82", 9, 3},
+	{"cong", "\xE2\x89\x85", 4, 3},
+	{"congdot", "\xE2\xA9\xAD", 7, 3},
+	{"conint", "\xE2\x88\xAE", 6, 3},
+	{"copf", "\xF0\x9D\x95\x94", 4, 4},
+	{"coprod", "\xE2\x88\x90", 6, 3},
+	{"copy", "\xC2\xA9", 4, 2},
+	{"copysr", "\xE2\x84\x97", 6, 3},
+	{"crarr", "\xE2\x86\xB5", 5, 3},
+	{"cross", "\xE2\x9C\x97", 5, 3},
+	{"cscr", "\xF0\x9D\x92\xB8", 4, 4},
+	{"csub", "\xE2\xAB\x8F", 4, 3},
+	{"csube", "\xE2\xAB\x91", 5, 3},
+	{"csup", "\xE2\xAB\x90", 4, 3},
+	{"csupe", "\xE2\xAB\x92", 5, 3},
+	{"ctdot", "\xE2\x8B\xAF", 5, 3},
+	{"cudarrl", "\xE2\xA4\xB8", 7, 3},
+	{"cudarrr", "\xE2\xA4\xB5", 7, 3},
+	{"cuepr", "\xE2\x8B\x9E", 5, 3},
+	{"cuesc", "\xE2\x8B\x9F", 5, 3},
+	{"cularr", "\xE2\x86\xB6", 6, 3},
+	{"cularrp", "\xE2\xA4\xBD", 7, 3},
+	{"cup", "\xE2\x88\xAA", 3, 3},
+	{"cupbrcap", "\xE2\xA9\x88", 8, 3},
+	{"cupcap", "\xE2\xA9\x86", 6, 3},
+	{"cupcup", "\xE2\xA9\x8A", 6, 3},
+	{"cupdot", "\xE2\x8A\x8D", 6, 3},
+	{"cupor", "\xE2\xA9\x85", 5, 3},
+	{"cups", "\xE2\x88\xAA\xEF\xB8\x80", 4, 6},
+	{"curarr", "\xE2\x86\xB7", 6, 3},
+	{"curarrm", "\xE2\xA4\xBC", 7, 3},
+	{"curlyeqprec", "\xE2\x8B\x9E", 11, 3},
+	{"curlyeqsucc", "\xE2\x8B\x9F", 11, 3},
+	{"curlyvee", "\xE2\x8B\x8E", 8, 3},
+	{"curlywedge", "\xE2\x8B\x8F", 10, 3},
+	{"curren", "\xC2\xA4", 6, 2},
+	{"curvearrowleft", "\xE2\x86\xB6", 14, 3},
+	{"curvearrowright", "\xE2\x86\xB7", 15, 3},
+	{"cuvee", "\xE2\x8B\x8E", 5, 3},
+	{"cuwed", "\xE2\x8B\x8F", 5, 3},
+	{"cwconint", "\xE2\x88\xB2", 8, 3},
+	{"cwint", "\xE2\x88\xB1", 5, 3},
+	{"cylcty", "\xE2\x8C\xAD", 6, 3},
+	{"dArr", "\xE2\x87\x93", 4, 3},
+	{"dHar", "\xE2\xA5\xA5", 4, 3},
+	{"dagger", "\xE2\x80\xA0", 6, 3},
+	{"daleth", "\xE2\x84\xB8", 6, 3},
+	{"darr", "\xE2\x86\x93", 4, 3},
+	{"dash", "\xE2\x80\x90", 4, 3},
+	{"dashv", "\xE2\x8A\xA3", 5, 3},
+	{"dbkarow", "\xE2\xA4\x8F", 7, 3},
+	{"dblac", "\xCB\x9D", 5, 2},
+	{"dcaron", "\xC4\x8F", 6, 2},
+	{"dcy", "\xD0\xB4", 3, 2},
+	{"dd", "\xE2\x85\x86", 2, 3},
+	{"ddagger", "\xE2\x80\xA1", 7, 3},
+	{"ddarr", "\xE2\x87\x8A", 5, 3},
+	{"ddotseq", "\xE2\xA9\xB7", 7, 3},
+	{"deg", "\xC2\xB0", 3, 2},
+	{"delta", "\xCE\xB4", 5, 2},
+	{"demptyv", "\xE2\xA6\xB1", 7, 3},
+	{"dfisht", "\xE2\xA5\xBF", 6, 3},
+	{"dfr", "\xF0\x9D\x94\xA1", 3, 4},
+	{"dharl", "\xE2\x87\x83", 5, 3},
+	{"dharr", "\xE2\x87\x82", 5, 3},
+	{"diam", "\xE2\x8B\x84", 4, 3},
+	{"diamond", "\xE2\x8B\x84", 7, 3},
+	{"diamondsuit", "\xE2\x99\xA6", 11, 3},
+	{"diams", "\xE2\x99\xA6", 5, 3},
+	{"die", "\xC2\xA8", 3, 2},
+	{"digamma", "\xCF\x9D", 7, 2},
+	{"disin", "\xE2\x8B\xB2", 5, 3},
+	{"div", "\xC3\xB7", 3, 2},
+	{"divide", "\xC3\xB7", 6, 2},
+	{"divideontimes", "\xE2\x8B\x87", 13, 3},
+	{"divonx", "\xE2\x8B\x87", 6, 3},
+	{"djcy", "\xD1\x92", 4, 2},
+	{"dlcorn", "\xE2\x8C\x9E", 6, 3},
+	{"dlcrop", "\xE2\x8C\x8D", 6, 3},
+	{"dollar", "\x24", 6, 1},
+	{"dopf", "\xF0\x9D\x95\x95", 4, 4},
+	{"dot", "\xCB\x99", 3, 2},
+	{"doteq", "\xE2\x89\x90", 5, 3},
+	{"doteqdot", "\xE2\x89\x91", 8, 3},
+	{"dotminus", "\xE2\x88\xB8", 8, 3},
+	{"dotplus", "\xE2\x88\x94", 7, 3},
+	{"dotsquare", "\xE2\x8A\xA1", 9, 3},
+	{"doublebarwedge", "\xE2\x8C\x86", 14, 3},
+	{"downarrow", "\xE2\x86\x93", 9, 3},
+	{"downdownarrows", "\xE2\x87\x8A", 14, 3},
+	{"downharpoonleft", "\xE2\x87\x83", 15, 3},
+	{"downharpoonright", "\xE2\x87\x82", 16, 3},
+	{"drbkarow", "\xE2\xA4\x90", 8, 3},
+	{"drcorn", "\xE2\x8C\x9F", 6, 3},
+	{"drcrop", "\xE2\x8C\x8C", 6, 3},
+	{"dscr", "\xF0\x9D\x92\xB9", 4, 4},
+	{"dscy", "\xD1\x95", 4, 2},
+	{"dsol", "\xE2\xA7\xB6", 4, 3},
+	{"dstrok", "\xC4\x91", 6, 2},
+	{"dtdot", "\xE2\x8B\xB1", 5, 3},
+	{"dtri", "\xE2\x96\xBF", 4, 3},
+	{"dtrif", "\xE2\x96\xBE", 5, 3},
+	{"duarr", "\xE2\x87\xB5", 5, 3},
+	{"duhar", "\xE2\xA5\xAF", 5, 3},
+	{"dwangle", "\xE2\xA6\xA6", 7, 3},
+	{"dzcy", "\xD1\x9F", 4, 2},
+	{"dzigrarr", "\xE2\x9F\xBF", 8, 3},
+	{"eDDot", "\xE2\xA9\xB7", 5, 3},
+	{"eDot", "\xE2\x89\x91", 4, 3},
+	{"eacute", "\xC3\xA9", 6, 2},
+	{"easter", "\xE2\xA9\xAE", 6, 3},
+	{"ecaron", "\xC4\x9B", 6, 2},
+	{"ecir", "\xE2\x89\x96", 4, 3},
+	{"ecirc", "\xC3\xAA", 5, 2},
+	{"ecolon", "\xE2\x89\x95", 6, 3},
+	{"ecy", "\xD1\x8D", 3, 2},
+	{"edot", "\xC4\x97", 4, 2},
+	{"ee", "\xE2\x85\x87", 2, 3},
+	{"efDot", "\xE2\x89\x92", 5, 3},
+	{"efr", "\xF0\x9D\x94\xA2", 3, 4},
+	{"eg", "\xE2\xAA\x9A", 2, 3},
+	{"egrave", "\xC3\xA8", 6, 2},
+	{"egs", "\xE2\xAA\x96", 3, 3},
+	{"egsdot", "\xE2\xAA\x98", 6, 3},
+	{"el", "\xE2\xAA\x99", 2, 3},
+	{"elinters", "\xE2\x8F\xA7", 8, 3},
+	{"ell", "\xE2\x84\x93", 3, 3},
+	{"els", "\xE2\xAA\x95", 3, 3},
+	{"elsdot", "\xE2\xAA\x97", 6, 3},
+	{"emacr", "\xC4\x93", 5, 2},
+	{"empty", "\xE2\x88\x85", 5, 3},
+	{"emptyset", "\xE2\x88\x85", 8, 3},
+	{"emptyv", "\xE2\x88\x85", 6, 3},
+	{"emsp", "\xE2\x80\x83", 4, 3},
+	{"emsp13", "\xE2\x80\x84", 6, 3},
+	{"emsp14", "\xE2\x80\x85", 6, 3},
+	{"eng", "\xC5\x8B", 3, 2},
+	{"ensp", "\xE2\x80\x82", 4, 3},
+	{"eogon", "\xC4\x99", 5, 2},
+	{"eopf", "\xF0\x9D\x95\x96", 4, 4},
+	{"epar", "\xE2\x8B\x95", 4, 3},
+	{"eparsl", "\xE2\xA7\xA3", 6, 3},
+	{"eplus", "\xE2\xA9\xB1", 5, 3},
+	{"epsi", "\xCE\xB5", 4, 2},
+	{"epsilon", "\xCE\xB5", 7, 2},
+	{"epsiv", "\xCF\xB5", 5, 2},
+	{"eqcirc", "\xE2\x89\x96", 6, 3},
+	{"eqcolon", "\xE2\x89\x95", 7, 3},
+	{"eqsim", "\xE2\x89\x82", 5, 3},
+	{"eqslantgtr", "\xE2\xAA\x96", 10, 3},
+	{"eqslantless", "\xE2\xAA\x95", 11, 3},
+	{"equals", "\x3D", 6, 1},
+	{"equest", "\xE2\x89\x9F", 6, 3},
+	{"equiv", "\xE2\x89\xA1", 5, 3},
+	{"equivDD", "\xE2\xA9\xB8", 7, 3},
+	{"eqvparsl", "\xE2\xA7\xA5", 8, 3},
+	{"erDot", "\xE2\x89\x93", 5, 3},
+	{"erarr", "\xE2\xA5\xB1", 5, 3},
+	{"escr", "\xE2\x84\xAF", 4, 3},
+	{"esdot", "\xE2\x89\x90", 5, 3},
+	{"esim", "\xE2\x89\x82", 4, 3},
+	{"eta", "\xCE\xB7", 3, 2},
+	{"eth", "\xC3\xB0", 3, 2},
+	{"euml", "\xC3\xAB", 4, 2},
+	{"euro", "\xE2\x82\xAC", 4, 3},
+	{"excl", "\x21", 4, 1},
+	{"exist", "\xE2\x88\x83", 5, 3},
+	{"expectation", "\xE2\x84\xB0", 11, 3},
+	{"exponentiale", "\xE2\x85\x87", 12, 3},
+	{"fallingdotseq", "\xE2\x89\x92", 13, 3},
+	{"fcy", "\xD1\x84", 3, 2},
+	{"female", "\xE2\x99\x80", 6, 3},
+	{"ffilig", "\xEF\xAC\x83", 6, 3},
+	{"fflig", "\xEF\xAC\x80", 5, 3},
+	{"ffllig", "\xEF\xAC\x84", 6, 3},
+	{"ffr", "\xF0\x9D\x94\xA3", 3, 4},
+	{"filig", "\xEF\xAC\x81", 5, 3},
+	{"fjlig", "\x66\x6A", 5, 2},
+	{"flat", "\xE2\x99\xAD", 4, 3},
+	{"fllig", "\xEF\xAC\x82", 5, 3},
+	{"fltns", "\xE2\x96\xB1", 5, 3},
+	{"fnof", "\xC6\x92", 4, 2},
+	{"fopf", "\xF0\x9D\x95\x97", 4, 4},
+	{"forall", "\xE2\x88\x80", 6, 3},
+	{"fork", "\xE2\x8B\x94", 4, 3},
+	{"forkv", "\xE2\xAB\x99", 5, 3},
+	{"fpartint", "\xE2\xA8\x8D", 8, 3},
+	{"frac12", "\xC2\xBD", 6, 2},
+	{"frac13", "\xE2\x85\x93", 6, 3},
+	{"frac14", "\xC2\xBC", 6, 2},
+	{"frac15", "\xE2\x85\x95", 6, 3},
+	{"frac16", "\xE2\x85\x99", 6, 3},
+	{"frac18", "\xE2\x85\x9B", 6, 3},
+	{"frac23", "\xE2\x85\x94", 6, 3},
+	{"frac25", "\xE2\x85\x96", 6, 3},
+	{"frac34", "\xC2\xBE", 6, 2},
+	{"frac35", "\xE2\x85\x97", 6, 3},
+	{"frac38", "\xE2\x85\x9C", 6, 3},
+	{"frac45", "\xE2\x85\x98", 6, 3},
+	{"frac56", "\xE2\x85\x9A", 6, 3},
+	{"frac58", "\xE2\x85\x9D", 6, 3},
+	{"frac78", "\xE2\x85\x9E", 6, 3},
+	{"frasl", "\xE2\x81\x84", 5, 3},
+	{"frown", "\xE2\x8C\xA2", 5, 3},
+	{"fscr", "\xF0\x9D\x92\xBB", 4, 4},
+	{"gE", "\xE2\x89\xA7", 2, 3},
+	{"gEl", "\xE2\xAA\x8C", 3, 3},
+	{"gacute", "\xC7\xB5", 6, 2},
+	{"gamma", "\xCE\xB3", 5, 2},
+	{"gammad", "\xCF\x9D", 6, 2},
+	{"gap", "\xE2\xAA\x86", 3, 3},
+	{"gbreve", "\xC4\x9F", 6, 2},
+	{"gcirc", "\xC4\x9D", 5, 2},
+	{"gcy", "\xD0\xB3", 3, 2},
+	{"gdot", "\xC4\xA1", 4, 2},
+	{"ge", "\xE2\x89\xA5", 2, 3},
+	{"gel", "\xE2\x8B\x9B", 3, 3},
+	{"geq", "\xE2\x89\xA5", 3, 3},
+	{"geqq", "\xE2\x89\xA7", 4, 3},
+	{"geqslant", "\xE2\xA9\xBE", 8, 3},
+	{"ges", "\xE2\xA9\xBE", 3, 3},
+	{"gescc", "\xE2\xAA\xA9", 5, 3},
+	{"gesdot", "\xE2\xAA\x80", 6, 3},
+	{"gesdoto", "\xE2\xAA\x82", 7, 3},
+	{"gesdotol", "\xE2\xAA\x84", 8, 3},
+	{"gesl", "\xE2\x8B\x9B\xEF\xB8\x80", 4, 6},
+	{"gesles", "\xE2\xAA\x94", 6, 3},
+	{"gfr", "\xF0\x9D\x94\xA4", 3, 4},
+	{"gg", "\xE2\x89\xAB", 2, 3},
+	{"ggg", "\xE2\x8B\x99", 3, 3},
+	{"gimel", "\xE2\x84\xB7", 5, 3},
+	{"gjcy", "\xD1\x93", 4, 2},
+	{"gl", "\xE2\x89\xB7", 2, 3},
+	{"glE", "\xE2\xAA\x92", 3, 3},
+	{"gla", "\xE2\xAA\xA5", 3, 3},
+	{"glj", "\xE2\xAA\xA4", 3, 3},
+	{"gnE", "\xE2\x89\xA9", 3, 3},
+	{"gnap", "\xE2\xAA\x8A", 4, 3},
+	{"gnapprox", "\xE2\xAA\x8A", 8, 3},
+	{"gne", "\xE2\xAA\x88", 3, 3},
+	{"gneq", "\xE2\xAA\x88", 4, 3},
+	{"gneqq", "\xE2\x89\xA9", 5, 3},
+	{"gnsim", "\xE2\x8B\xA7", 5, 3},
+	{"gopf", "\xF0\x9D\x95\x98", 4, 4},
+	{"grave", "\x60", 5, 1},
+	{"gscr", "\xE2\x84\x8A", 4, 3},
+	{"gsim", "\xE2\x89\xB3", 4, 3},
+	{"gsime", "\xE2\xAA\x8E", 5, 3},
+	{"gsiml", "\xE2\xAA\x90", 5, 3},
+	{"gt", "\x3E", 2, 1},
+	{"gtcc", "\xE2\xAA\xA7", 4, 3},
+	{"gtcir", "\xE2\xA9\xBA", 5, 3},
+	{"gtdot", "\xE2\x8B\x97", 5, 3},
+	{"gtlPar", "\xE2\xA6\x95", 6, 3},
+	{"gtquest", "\xE2\xA9\xBC", 7, 3},
+	{"gtrapprox", "\xE2\xAA\x86", 9, 3},
+	{"gtrarr", "\xE2\xA5\xB8", 6, 3},
+	{"gtrdot", "\xE2\x8B\x97", 6, 3},
+	{"gtreqless", "\xE2\x8B\x9B", 9, 3},
+	{"gtreqqless", "\xE2\xAA\x8C", 10, 3},
+	{"gtrless", "\xE2\x89\xB7", 7, 3},
+	{"gtrsim", "\xE2\x89\xB3", 6, 3},
+	{"gvertneqq", "\xE2\x89\xA9\xEF\xB8\x80", 9, 6},
+	{"gvnE", "\xE2\x89\xA9\xEF\xB8\x80", 4, 6},
+	{"hArr", "\xE2\x87\x94", 4, 3},
+	{"hairsp", "\xE2\x80\x8A", 6, 3},
+	{"half", "\xC2\xBD", 4, 2},
+	{"hamilt", "\xE2\x84\x8B", 6, 3},
+	{"hardcy", "\xD1\x8A", 6, 2},
+	{"harr", "\xE2\x86\x94", 4, 3},
+	{"harrcir", "\xE2\xA5\x88", 7, 3},
+	{"harrw", "\xE2\x86\xAD", 5, 3},
+	{"hbar", "\xE2\x84\x8F", 4, 3},
+	{"hcirc", "\xC4\xA5", 5, 2},
+	{"hearts", "\xE2\x99\xA5", 6, 3},
+	{"heartsuit", "\xE2\x99\xA5", 9, 3},
+	{"hellip", "\xE2\x80\xA6", 6, 3},
+	{"hercon", "\xE2\x8A\xB9", 6, 3},
+	{"hfr", "\xF0\x9D\x94\xA5", 3, 4},
+	{"hksearow", "\xE2\xA4\xA5", 8, 3},
+	{"hkswarow", "\xE2\xA4\xA6", 8, 3},
+	{"hoarr", "\xE2\x87\xBF", 5, 3},
+	{"homtht", "\xE2\x88\xBB", 6, 3},
+	{"hookleftarrow", "\xE2\x86\xA9", 13, 3},
+	{"hookrightarrow", "\xE2\x86\xAA", 14, 3},
+	{"hopf", "\xF0\x9D\x95\x99", 4, 4},
+	{"horbar", "\xE2\x80\x95", 6, 3},
+	{"hscr", "\xF0\x9D\x92\xBD", 4, 4},
+	{"hslash", "\xE2\x84\x8F", 6, 3},
+	{"hstrok", "\xC4\xA7", 6, 2},
+	{"hybull", "\xE2\x81\x83", 6, 3},
+	{"hyphen", "\xE2\x80\x90", 6, 3},
+	{"iacute", "\xC3\xAD", 6, 2},
+	{"ic", "\xE2\x81\xA3", 2, 3},
+	{"icirc", "\xC3\xAE", 5, 2},
+	{"icy", "\xD0\xB8", 3, 2},
+	{"iecy", "\xD0\xB5", 4, 2},
+	{"iexcl", "\xC2\xA1", 5, 2},
+	{"iff", "\xE2\x87\x94", 3, 3},
+	{"ifr", "\xF0\x9D\x94\xA6", 3, 4},
+	{"igrave", "\xC3\xAC", 6, 2},
+	{"ii", "\xE2\x85\x88", 2, 3},
+	{"iiiint", "\xE2\xA8\x8C", 6, 3},
+	{"iiint", "\xE2\x88\xAD", 5, 3},
+	{"iinfin", "\xE2\xA7\x9C", 6, 3},
+	{"iiota", "\xE2\x84\xA9", 5, 3},
+	{"ijlig", "\xC4\xB3", 5, 2},
+	{"imacr", "\xC4\xAB", 5, 2},
+	{"image", "\xE2\x84\x91", 5, 3},
+	{"imagline", "\xE2\x84\x90", 8, 3},
+	{"imagpart", "\xE2\x84\x91", 8, 3},
+	{"imath", "\xC4\xB1", 5, 2},
+	{"imof", "\xE2\x8A\xB7", 4, 3},
+	{"imped", "\xC6\xB5", 5, 2},
+	{"in", "\xE2\x88\x88", 2, 3},
+	{"incare", "\xE2\x84\x85", 6, 3},
+	{"infin", "\xE2\x88\x9E", 5, 3},
+	{"infintie", "\xE2\xA7\x9D", 8, 3},
+	{"inodot", "\xC4\xB1", 6, 2},
+	{"int", "\xE2\x88\xAB", 3, 3},
+	{"intcal", "\xE2\x8A\xBA", 6, 3},
+	{"integers", "\xE2\x84\xA4", 8, 3},
+	{"intercal", "\xE2\x8A\xBA", 8, 3},
+	{"intlarhk", "\xE2\xA8\x97", 8, 3},
+	{"intprod", "\xE2\xA8\xBC", 7, 3},
+	{"iocy", "\xD1\x91", 4, 2},
+	{"iogon", "\xC4\xAF", 5, 2},
+	{"iopf", "\xF0\x9D\x95\x9A", 4, 4},
+	{"iota", "\xCE\xB9", 4, 2},
+	{"iprod", "\xE2\xA8\xBC", 5, 3},
+	{"iquest", "\xC2\xBF", 6, 2},
+	{"iscr", "\xF0\x9D\x92\xBE", 4, 4},
+	{"isin", "\xE2\x88\x88", 4, 3},
+	{"isinE", "\xE2\x8B\xB9", 5, 3},
+	{"isindot", "\xE2\x8B\xB5", 7, 3},
+	{"isins", "\xE2\x8B\xB4", 5, 3},
+	{"isinsv", "\xE2\x8B\xB3", 6, 3},
+	{"isinv", "\xE2\x88\x88", 5, 3},
+	{"it", "\xE2\x81\xA2", 2, 3},
+	{"itilde", "\xC4\xA9", 6, 2},
+	{"iukcy", "\xD1\x96", 5, 2},
+	{"iuml", "\xC3\xAF", 4, 2},
+	{"jcirc", "\xC4\xB5", 5, 2},
+	{"jcy", "\xD0\xB9", 3, 2},
+	{"jfr", "\xF0\x9D\x94\xA7", 3, 4},
+	{"jmath", "\xC8\xB7", 5, 2},
+	{"jopf", "\xF0\x9D\x95\x9B", 4, 4},
+	{"jscr", "\xF0\x9D\x92\xBF", 4, 4},
+	{"jsercy", "\xD1\x98", 6, 2},
+	{"jukcy", "\xD1\x94", 5, 2},
+	{"kappa", "\xCE\xBA", 5, 2},
+	{"kappav", "\xCF\xB0", 6, 2},
+	{"kcedil", "\xC4\xB7", 6, 2},
+	{"kcy", "\xD0\xBA", 3, 2},
+	{"kfr", "\xF0\x9D\x94\xA8", 3, 4},
+	{"kgreen", "\xC4\xB8", 6, 2},
+	{"khcy", "\xD1\x85", 4, 2},
+	{"kjcy", "\xD1\x9C", 4, 2},
+	{"kopf", "\xF0\x9D\x95\x9C", 4, 4},
+	{"kscr", "\xF0\x9D\x93\x80", 4, 4},
+	{"lAarr", "\xE2\x87\x9A", 5, 3},
+	{"lArr", "\xE2\x87\x90", 4, 3},
+	{"lAtail", "\xE2\xA4\x9B", 6, 3},
+	{"lBarr", "\xE2\xA4\x8E", 5, 3},
+	{"lE", "\xE2\x89\xA6", 2, 3},
+	{"lEg", "\xE2\xAA\x8B", 3, 3},
+	{"lHar", "\xE2\xA5\xA2", 4, 3},
+	{"lacute", "\xC4\xBA", 6, 2},
+	{"laemptyv", "\xE2\xA6\xB4", 8, 3},
+	{"lagran", "\xE2\x84\x92", 6, 3},
+	{"lambda", "\xCE\xBB", 6, 2},
+	{"lang", "\xE2\x9F\xA8", 4, 3},
+	{"langd", "\xE2\xA6\x91", 5, 3},
+	{"langle", "\xE2\x9F\xA8", 6, 3},
+	{"lap", "\xE2\xAA\x85", 3, 3},
+	{"laquo", "\xC2\xAB", 5, 2},
+	{"larr", "\xE2\x86\x90", 4, 3},
+	{"larrb", "\xE2\x87\xA4", 5, 3},
+	{"larrbfs", "\xE2\xA4\x9F", 7, 3},
+	{"larrfs", "\xE2\xA4\x9D", 6, 3},
+	{"larrhk", "\xE2\x86\xA9", 6, 3},
+	{"larrlp", "\xE2\x86\xAB", 6, 3},
+	{"larrpl", "\xE2\xA4\xB9", 6, 3},
+	{"larrsim", "\xE2\xA5\xB3", 7, 3},
+	{"larrtl", "\xE2\x86\xA2", 6, 3},
+	{"lat", "\xE2\xAA\xAB", 3, 3},
+	{"latail", "\xE2\xA4\x99", 6, 3},
+	{"late", "\xE2\xAA\xAD", 4, 3},
+	{"lates", "\xE2\xAA\xAD\xEF\xB8\x80", 5, 6},
+	{"lbarr", "\xE2\xA4\x8C", 5, 3},
+	{"lbbrk", "\xE2\x9D\xB2", 5, 3},
+	{"lbrace", "\x7B", 6, 1},
+	{"lbrack", "\x5B", 6, 1},
+	{"lbrke", "\xE2\xA6\x8B", 5, 3},
+	{"lbrksld", "\xE2\xA6\x8F", 7, 3},
+	{"lbrkslu", "\xE2\xA6\x8D", 7, 3},
+	{"lcaron", "\xC4\xBE", 6, 2},
+	{"lcedil", "\xC4\xBC", 6, 2},
+	{"lceil", "\xE2\x8C\x88", 5, 3},
+	{"lcub", "\x7B", 4, 1},
+	{"lcy", "\xD0\xBB", 3, 2},
+	{"ldca", "\xE2\xA4\xB6", 4, 3},
+	{"ldquo", "\xE2\x80\x9C", 5, 3},
+	{"ldquor", "\xE2\x80\x9E", 6, 3},
+	{"ldrdhar", "\xE2\xA5\xA7", 7, 3},
+	{"ldrushar", "\xE2\xA5\x8B", 8, 3},
+	{"ldsh", "\xE2\x86\xB2", 4, 3},
+	{"le", "\xE2\x89\xA4", 2, 3},
+	{"leftarrow", "\xE2\x86\x90", 9, 3},
+	{"leftarrowtail", "\xE2\x86\xA2", 13, 3},
+	{"leftharpoondown", "\xE2\x86\xBD", 15, 3},
+	{"leftharpoonup", "\xE2\x86\xBC", 13, 3},
+	{"leftleftarrows", "\xE2\x87\x87", 14, 3},
+	{"leftrightarrow", "\xE2\x86\x94", 14, 3},
+	{"leftrightarrows", "\xE2\x87\x86", 15, 3},
+	{"leftrightharpoons", "\xE2\x87\x8B", 17, 3},
+	{"leftrightsquigarrow", "\xE2\x86\xAD", 19, 3},
+	{"leftthreetimes", "\xE2\x8B\x8B", 14, 3},
+	{"leg", "\xE2\x8B\x9A", 3, 3},
+	{"leq", "\xE2\x89\xA4", 3, 3},
+	{"leqq", "\xE2\x89\xA6", 4, 3},
+	{"leqslant", "\xE2\xA9\xBD", 8, 3},
+	{"les", "\xE2\xA9\xBD", 3, 3},
+	{"lescc", "\xE2\xAA\xA8", 5, 3},
+	{"lesdot", "\xE2\xA9\xBF", 6, 3},
+	{"lesdoto", "\xE2\xAA\x81", 7, 3},
+	{"lesdotor", "\xE2\xAA\x83", 8, 3},
+	{"lesg", "\xE2\x8B\x9A\xEF\xB8\x80", 4, 6},
+	{"lesges", "\xE2\xAA\x93", 6, 3},
+	{"lessapprox", "\xE2\xAA\x85", 10, 3},
+	{"lessdot", "\xE2\x8B\x96", 7, 3},
+	{"lesseqgtr", "\xE2\x8B\x9A", 9, 3},
+	{"lesseqqgtr", "\xE2\xAA\x8B", 10, 3},
+	{"lessgtr", "\xE2\x89\xB6", 7, 3},
+	{"lesssim", "\xE2\x89\xB2", 7, 3},
+	{"lfisht", "\xE2\xA5\xBC", 6, 3},
+	{"lfloor", "\xE2\x8C\x8A", 6, 3},
+	{"lfr", "\xF0\x9D\x94\xA9", 3, 4},
+	{"lg", "\xE2\x89\xB6", 2, 3},
+	{"lgE", "\xE2\xAA\x91", 3, 3},
+	{"lhard", "\xE2\x86\xBD", 5, 3},
+	{"lharu", "\xE2\x86\xBC", 5, 3},
+	{"lharul", "\xE2\xA5\xAA", 6, 3},
+	{"lhblk", "\xE2\x96\x84", 5, 3},
+	{"ljcy", "\xD1\x99", 4, 2},
+	{"ll", "\xE2\x89\xAA", 2, 3},
+	{"llarr", "\xE2\x87\x87", 5, 3},
+	{"llcorner", "\xE2\x8C\x9E", 8, 3},
+	{"llhard", "\xE2\xA5\xAB", 6, 3},
+	{"lltri", "\xE2\x97\xBA", 5, 3},
+	{"lmidot", "\xC5\x80", 6, 2},
+	{"lmoust", "\xE2\x8E\xB0", 6, 3},
+	{"lmoustache", "\xE2\x8E\xB0", 10, 3},
+	{"lnE", "\xE2\x89\xA8", 3, 3},
+	{"lnap", "\xE2\xAA\x89", 4, 3},
+	{"lnapprox", "\xE2\xAA\x89", 8, 3},
+	{"lne", "\xE2\xAA\x87", 3, 3},
+	{"lneq", "\xE2\xAA\x87", 4, 3},
+	{"lneqq", "\xE2\x89\xA8", 5, 3},
+	{"lnsim", "\xE2\x8B\xA6", 5, 3},
+	{"loang", "\xE2\x9F\xAC", 5, 3},
+	{"loarr", "\xE2\x87\xBD", 5, 3},
+	{"lobrk", "\xE2\x9F\xA6", 5, 3},
+	{"longleftarrow", "\xE2\x9F\xB5", 13, 3},
+	{"longleftrightarrow", "\xE2\x9F\xB7", 18, 3},
+	{"longmapsto", "\xE2\x9F\xBC", 10, 3},
+	{"longrightarrow", "\xE2\x9F\xB6", 14, 3},
+	{"looparrowleft", "\xE2\x86\xAB", 13, 3},
+	{"looparrowright", "\xE2\x86\xAC", 14, 3},
+	{"lopar", "\xE2\xA6\x85", 5, 3},
+	{"lopf", "\xF0\x9D\x95\x9D", 4, 4},
+	{"loplus", "\xE2\xA8\xAD", 6, 3},
+	{"lotimes", "\xE2\xA8\xB4", 7, 3},
+	{"lowast", "\xE2\x88\x97", 6, 3},
+	{"lowbar", "\x5F", 6, 1},
+	{"loz", "\xE2\x97\x8A", 3, 3},
+	{"lozenge", "\xE2\x97\x8A", 7, 3},
+	{"lozf", "\xE2\xA7\xAB", 4, 3},
+	{"lpar", "\x28", 4, 1},
+	{"lparlt", "\xE2\xA6\x93", 6, 3},
+	{"lrarr", "\xE2\x87\x86", 5, 3},
+	{"lrcorner", "\xE2\x8C\x9F", 8, 3},
+	{"lrhar", "\xE2\x87\x8B", 5, 3},
+	{"lrhard", "\xE2\xA5\xAD", 6, 3},
+	{"lrm", "\xE2\x80\x8E", 3, 3},
+	{"lrtri", "\xE2\x8A\xBF", 5, 3},
+	{"lsaquo", "\xE2\x80\xB9", 6, 3},
+	{"lscr", "\xF0\x9D\x93\x81", 4, 4},
+	{"lsh", "\xE2\x86\xB0", 3, 3},
+	{"lsim", "\xE2\x89\xB2", 4, 3},
+	{"lsime", "\xE2\xAA\x8D", 5, 3},
+	{"lsimg", "\xE2\xAA\x8F", 5, 3},
+	{"lsqb", "\x5B", 4, 1},
+	{"lsquo", "\xE2\x80\x98", 5, 3},
+	{"lsquor", "\xE2\x80\x9A", 6, 3},
+	{"lstrok", "\xC5\x82", 6, 2},
+	{"lt", "\x3C", 2, 1},
+	{"ltcc", "\xE2\xAA\xA6", 4, 3},
+	{"ltcir", "\xE2\xA9\xB9", 5, 3},
+	{"ltdot", "\xE2\x8B\x96", 5, 3},
+	{"lthree", "\xE2\x8B\x8B", 6, 3},
+	{"ltimes", "\xE2\x8B\x89", 6, 3},
+	{"ltlarr", "\xE2\xA5\xB6", 6, 3},
+	{"ltquest", "\xE2\xA9\xBB", 7, 3},
+	{"ltrPar", "\xE2\xA6\x96", 6, 3},
+	{"ltri", "\xE2\x97\x83", 4, 3},
+	{"ltrie", "\xE2\x8A\xB4", 5, 3},
+	{"ltrif", "\xE2\x97\x82", 5, 3},
+	{"lurdshar", "\xE2\xA5\x8A", 8, 3},
+	{"luruhar", "\xE2\xA5\xA6", 7, 3},
+	{"lvertneqq", "\xE2\x89\xA8\xEF\xB8\x80", 9, 6},
+	{"lvnE", "\xE2\x89\xA8\xEF\xB8\x80", 4, 6},
+	{"mDDot", "\xE2\x88\xBA", 5, 3},
+	{"macr", "\xC2\xAF", 4, 2},
+	{"male", "\xE2\x99\x82", 4, 3},
+	{"malt", "\xE2\x9C\xA0", 4, 3},
+	{"maltese", "\xE2\x9C\xA0", 7, 3},
+	{"map", "\xE2\x86\xA6", 3, 3},
+	{"mapsto", "\xE2\x86\xA6", 6, 3},
+	{"mapstodown", "\xE2\x86\xA7", 10, 3},
+	{"mapstoleft", "\xE2\x86\xA4", 10, 3},
+	{"mapstoup", "\xE2\x86\xA5", 8, 3},
+	{"marker", "\xE2\x96\xAE", 6, 3},
+	{"mcomma", "\xE2\xA8\xA9", 6, 3},
+	{"mcy", "\xD0\xBC", 3, 2},
+	{"mdash", "\xE2\x80\x94", 5, 3},
+	{"measuredangle", "\xE2\x88\xA1", 13, 3},
+	{"mfr", "\xF0\x9D\x94\xAA", 3, 4},
+	{"mho", "\xE2\x84\xA7", 3, 3},
+	{"micro", "\xC2\xB5", 5, 2},
+	{"mid", "\xE2\x88\xA3", 3, 3},
+	{"midast", "\x2A", 6, 1},
+	{"midcir", "\xE2\xAB\xB0", 6, 3},
+	{"middot", "\xC2\xB7", 6, 2},
+	{"minus", "\xE2\x88\x92", 5, 3},
+	{"minusb", "\xE2\x8A\x9F", 6, 3},
+	{"minusd", "\xE2\x88\xB8", 6, 3},
+	{"minusdu", "\xE2\xA8\xAA", 7, 3},
+	{"mlcp", "\xE2\xAB\x9B", 4, 3},
+	{"mldr", "\xE2\x80\xA6", 4, 3},
+	{"mnplus", "\xE2\x88\x93", 6, 3},
+	{"models", "\xE2\x8A\xA7", 6, 3},
+	{"mopf", "\xF0\x9D\x95\x9E", 4, 4},
+	{"mp", "\xE2\x88\x93", 2, 3},
+	{"mscr", "\xF0\x9D\x93\x82", 4, 4},
+	{"mstpos", "\xE2\x88\xBE", 6, 3},
+	{"mu", "\xCE\xBC", 2, 2},
+	{"multimap", "\xE2\x8A\xB8", 8, 3},
+	{"mumap", "\xE2\x8A\xB8", 5, 3},
+	{"nGg", "\xE2\x8B\x99\xCC\xB8", 3, 5},
+	{"nGt", "\xE2\x89\xAB\xE2\x83\x92", 3, 6},
+	{"nGtv", "\xE2\x89\xAB\xCC\xB8", 4, 5},
+	{"nLeftarrow", "\xE2\x87\x8D", 10, 3},
+	{"nLeftrightarrow", "\xE2\x87\x8E", 15, 3},
+	{"nLl", "\xE2\x8B\x98\xCC\xB8", 3, 5},
+	{"nLt", "\xE2\x89\xAA\xE2\x83\x92", 3, 6},
+	{"nLtv", "\xE2\x89\xAA\xCC\xB8", 4, 5},
+	{"nRightarrow", "\xE2\x87\x8F", 11, 3},
+	{"nVDash", "\xE2\x8A\xAF", 6, 3},
+	{"nVdash", "\xE2\x8A\xAE", 6, 3},
+	{"nabla", "\xE2\x88\x87", 5, 3},
+	{"nacute", "\xC5\x84", 6, 2},
+	{"nang", "\xE2\x88\xA0\xE2\x83\x92", 4, 6},
+	{"nap", "\xE2\x89\x89", 3, 3},
+	{"napE", "\xE2\xA9\xB0\xCC\xB8", 4, 5},
+	{"napid", "\xE2\x89\x8B\xCC\xB8", 5, 5},
+	{"napos", "\xC5\x89", 5, 2},
+	{"napprox", "\xE2\x89\x89", 7, 3},
+	{"natur", "\xE2\x99\xAE", 5, 3},
+	{"natural", "\xE2\x99\xAE", 7, 3},
+	{"naturals", "\xE2\x84\x95", 8, 3},
+	{"nbsp", "\xC2\xA0", 4, 2},
+	{"nbump", "\xE2\x89\x8E\xCC\xB8", 5, 5},
+	{"nbumpe", "\xE2\x89\x8F\xCC\xB8", 6, 5},
+	{"ncap", "\xE2\xA9\x83", 4, 3},
+	{"ncaron", "\xC5\x88", 6, 2},
+	{"ncedil", "\xC5\x86", 6, 2},
+	{"ncong", "\xE2\x89\x87", 5, 3},
+	{"ncongdot", "\xE2\xA9\xAD\xCC\xB8", 8, 5},
+	{"ncup", "\xE2\xA9\x82", 4, 3},
+	{"ncy", "\xD0\xBD", 3, 2},
+	{"ndash", "\xE2\x80\x93", 5, 3},
+	{"ne", "\xE2\x89\xA0", 2, 3},
+	{"neArr", "\xE2\x87\x97", 5, 3},
+	{"nearhk", "\xE2\xA4\xA4", 6, 3},
+	{"nearr", "\xE2\x86\x97", 5, 3},
+	{"nearrow", "\xE2\x86\x97", 7, 3},
+	{"nedot", "\xE2\x89\x90\xCC\xB8", 5, 5},
+	{"nequiv", "\xE2\x89\xA2", 6, 3},
+	{"nesear", "\xE2\xA4\xA8", 6, 3},
+	{"nesim", "\xE2\x89\x82\xCC\xB8", 5, 5},
+	{"nexist", "\xE2\x88\x84", 6, 3},
+	{"nexists", "\xE2\x88\x84", 7, 3},
+	{"nfr", "\xF0\x9D\x94\xAB", 3, 4},
+	{"ngE", "\xE2\x89\xA7\xCC\xB8", 3, 5},
+	{"nge", "\xE2\x89\xB1", 3, 3},
+	{"ngeq", "\xE2\x89\xB1", 4, 3},
+	{"ngeqq", "\xE2\x89\xA7\xCC\xB8", 5, 5},
+	{"ngeqslant", "\xE2\xA9\xBE\xCC\xB8", 9, 5},
+	{"nges", "\xE2\xA9\xBE\xCC\xB8", 4, 5},
+	{"ngsim", "\xE2\x89\xB5", 5, 3},
+	{"ngt", "\xE2\x89\xAF", 3, 3},
+	{"ngtr", "\xE2\x89\xAF", 4, 3},
+	{"nhArr", "\xE2\x87\x8E", 5, 3},
+	{"nharr", "\xE2\x86\xAE", 5, 3},
+	{"nhpar", "\xE2\xAB\xB2", 5, 3},
+	{"ni", "\xE2\x88\x8B", 2, 3},
+	{"nis", "\xE2\x8B\xBC", 3, 3},
+	{"nisd", "\xE2\x8B\xBA", 4, 3},
+	{"niv", "\xE2\x88\x8B", 3, 3},
+	{"njcy", "\xD1\x9A", 4, 2},
+	{"nlArr", "\xE2\x87\x8D", 5, 3},
+	{"nlE", "\xE2\x89\xA6\xCC\xB8", 3, 5},
+	{"nlarr", "\xE2\x86\x9A", 5, 3},
+	{"nldr", "\xE2\x80\xA5", 4, 3},
+	{"nle", "\xE2\x89\xB0", 3, 3},
+	{"nleftarrow", "\xE2\x86\x9A", 10, 3},
+	{"nleftrightarrow", "\xE2\x86\xAE", 15, 3},
+	{"nleq", "\xE2\x89\xB0", 4, 3},
+	{"nleqq", "\xE2\x89\xA6\xCC\xB8", 5, 5},
+	{"nleqslant", "\xE2\xA9\xBD\xCC\xB8", 9, 5},
+	{"nles", "\xE2\xA9\xBD\xCC\xB8", 4, 5},
+	{"nless", "\xE2\x89\xAE", 5, 3},
+	{"nlsim", "\xE2\x89\xB4", 5, 3},
+	{"nlt", "\xE2\x89\xAE", 3, 3},
+	{"nltri", "\xE2\x8B\xAA", 5, 3},
+	{"nltrie", "\xE2\x8B\xAC", 6, 3},
+	{"nmid", "\xE2\x88\xA4", 4, 3},
+	{"nopf", "\xF0\x9D\x95\x9F", 4, 4},
+	{"not", "\xC2\xAC", 3, 2},
+	{"notin", "\xE2\x88\x89", 5, 3},
+	{"notinE", "\xE2\x8B\xB9\xCC\xB8", 6, 5},
+	{"notindot", "\xE2\x8B\xB5\xCC\xB8", 8, 5},
+	{"notinva", "\xE2\x88\x89", 7, 3},
+	{"notinvb", "\xE2\x8B\xB7", 7, 3},
+	{"notinvc", "\xE2\x8B\xB6", 7, 3},
+	{"notni", "\xE2\x88\x8C", 5, 3},
+	{"notniva", "\xE2\x88\x8C", 7, 3},
+	{"notnivb", "\xE2\x8B\xBE", 7, 3},
+	{"notnivc", "\xE2\x8B\xBD", 7, 3},
+	{"npar", "\xE2\x88\xA6", 4, 3},
+	{"nparallel", "\xE2\x88\xA6", 9, 3},
+	{"nparsl", "\xE2\xAB\xBD\xE2\x83\xA5", 6, 6},
+	{"npart", "\xE2\x88\x82\xCC\xB8", 5, 5},
+	{"npolint", "\xE2\xA8\x94", 7, 3},
+	{"npr", "\xE2\x8A\x80", 3, 3},
+	{"nprcue", "\xE2\x8B\xA0", 6, 3},
+	{"npre", "\xE2\xAA\xAF\xCC\xB8", 4, 5},
+	{"nprec", "\xE2\x8A\x80", 5, 3},
+	{"npreceq", "\xE2\xAA\xAF\xCC\xB8", 7, 5},
+	{"nrArr", "\xE2\x87\x8F", 5, 3},
+	{"nrarr", "\xE2\x86\x9B", 5, 3},
+	{"nrarrc", "\xE2\xA4\xB3\xCC\xB8", 6, 5},
+	{"nrarrw", "\xE2\x86\x9D\xCC\xB8", 6, 5},
+	{"nrightarrow", "\xE2\x86\x9B", 11, 3},
+	{"nrtri", "\xE2\x8B\xAB", 5, 3},
+	{"nrtrie", "\xE2\x8B\xAD", 6, 3},
+	{"nsc", "\xE2\x8A\x81", 3, 3},
+	{"nsccue", "\xE2\x8B\xA1", 6, 3},
+	{"nsce", "\xE2\xAA\xB0\xCC\xB8", 4, 5},
+	{"nscr", "\xF0\x9D\x93\x83", 4, 4},
+	{"nshortmid", "\xE2\x88\xA4", 9, 3},
+	{"nshortparallel", "\xE2\x88\xA6", 14, 3},
+	{"nsim", "\xE2\x89\x81", 4, 3},
+	{"nsime", "\xE2\x89\x84", 5, 3},
+	{"nsimeq", "\xE2\x89\x84", 6, 3},
+	{"nsmid", "\xE2\x88\xA4", 5, 3},
+	{"nspar", "\xE2\x88\xA6", 5, 3},
+	{"nsqsube", "\xE2\x8B\xA2", 7, 3},
+	{"nsqsupe", "\xE2\x8B\xA3", 7, 3},
+	{"nsub", "\xE2\x8A\x84", 4, 3},
+	{"nsubE", "\xE2\xAB\x85\xCC\xB8", 5, 5},
+	{"nsube", "\xE2\x8A\x88", 5, 3},
+	{"nsubset", "\xE2\x8A\x82\xE2\x83\x92", 7, 6},
+	{"nsubseteq", "\xE2\x8A\x88", 9, 3},
+	{"nsubseteqq", "\xE2\xAB\x85\xCC\xB8", 10, 5},
+	{"nsucc", "\xE2\x8A\x81", 5, 3},
+	{"nsucceq", "\xE2\xAA\xB0\xCC\xB8", 7, 5},
+	{"nsup", "\xE2\x8A\x85", 4, 3},
+	{"nsupE", "\xE2\xAB\x86\xCC\xB8", 5, 5},
+	{"nsupe", "\xE2\x8A\x89", 5, 3},
+	{"nsupset", "\xE2\x8A\x83\xE2\x83\x92", 7, 6},
+	{"nsupseteq", "\xE2\x8A\x89", 9, 3},
+	{"nsupseteqq", "\xE2\xAB\x86\xCC\xB8", 10, 5},
+	{"ntgl", "\xE2\x89\xB9", 4, 3},
+	{"ntilde", "\xC3\xB1", 6, 2},
+	{"ntlg", "\xE2\x89\xB8", 4, 3},
+	{"ntriangleleft", "\xE2\x8B\xAA", 13, 3},
+	{"ntrianglelefteq", "\xE2\x8B\xAC", 15, 3},
+	{"ntriangleright", "\xE2\x8B\xAB", 14, 3},
+	{"ntrianglerighteq", "\xE2\x8B\xAD", 16, 3},
+	{"nu", "\xCE\xBD", 2, 2},
+	{"num", "\x23", 3, 1},
+	{"numero", "\xE2\x84\x96", 6, 3},
+	{"numsp", "\xE2\x80\x87", 5, 3},
+	{"nvDash", "\xE2\x8A\xAD", 6, 3},
+	{"nvHarr", "\xE2\xA4\x84", 6, 3},
+	{"nvap", "\xE2\x89\x8D\xE2\x83\x92", 4, 6},
+	{"nvdash", "\xE2\x8A\xAC", 6, 3},
+	{"nvge", "\xE2\x89\xA5\xE2\x83\x92", 4, 6},
+	{"nvgt", "\x3E\xE2\x83\x92", 4, 4},
+	{"nvinfin", "\xE2\xA7\x9E", 7, 3},
+	{"nvlArr", "\xE2\xA4\x82", 6, 3},
+	{"nvle", "\xE2\x89\xA4\xE2\x83\x92", 4, 6},
+	{"nvlt", "\x3C\xE2\x83\x92", 4, 4},
+	{"nvltrie", "\xE2\x8A\xB4\xE2\x83\x92", 7, 6},
+	{"nvrArr", "\xE2\xA4\x83", 6, 3},
+	{"nvrtrie", "\xE2\x8A\xB5\xE2\x83\x92", 7, 6},
+	{"nvsim", "\xE2\x88\xBC\xE2\x83\x92", 5, 6},
+	{"nwArr", "\xE2\x87\x96", 5, 3},
+	{"nwarhk", "\xE2\xA4\xA3", 6, 3},
+	{"nwarr", "\xE2\x86\x96", 5, 3},
+	{"nwarrow", "\xE2\x86\x96", 7, 3},
+	{"nwnear", "\xE2\xA4\xA7", 6, 3},
+	{"oS", "\xE2\x93\x88", 2, 3},
+	{"oacute", "\xC3\xB3", 6, 2},
+	{"oast", "\xE2\x8A\x9B", 4, 3},
+	{"ocir", "\xE2\x8A\x9A", 4, 3},
+	{"ocirc", "\xC3\xB4", 5, 2},
+	{"ocy", "\xD0\xBE", 3, 2},
+	{"odash", "\xE2\x8A\x9D", 5, 3},
+	{"odblac", "\xC5\x91", 6, 2},
+	{"odiv", "\xE2\xA8\xB8", 4, 3},
+	{"odot", "\xE2\x8A\x99", 4, 3},
+	{"odsold", "\xE2\xA6\xBC", 6, 3},
+	{"oelig", "\xC5\x93", 5, 2},
+	{"ofcir", "\xE2\xA6\xBF", 5, 3},
+	{"ofr", "\xF0\x9D\x94\xAC", 3, 4},
+	{"ogon", "\xCB\x9B", 4, 2},
+	{"ograve", "\xC3\xB2", 6, 2},
+	{"ogt", "\xE2\xA7\x81", 3, 3},
+	{"ohbar", "\xE2\xA6\xB5", 5, 3},
+	{"ohm", "\xCE\xA9", 3, 2},
+	{"oint", "\xE2\x88\xAE", 4, 3},
+	{"olarr", "\xE2\x86\xBA", 5, 3},
+	{"olcir", "\xE2\xA6\xBE", 5, 3},
+	{"olcross", "\xE2\xA6\xBB", 7, 3},
+	{"oline", "\xE2\x80\xBE", 5, 3},
+	{"olt", "\xE2\xA7\x80", 3, 3},
+	{"omacr", "\xC5\x8D", 5, 2},
+	{"omega", "\xCF\x89", 5, 2},
+	{"omicron", "\xCE\xBF", 7, 2},
+	{"omid", "\xE2\xA6\xB6", 4, 3},
+	{"ominus", "\xE2\x8A\x96", 6, 3},
+	{"oopf", "\xF0\x9D\x95\xA0", 4, 4},
+	{"opar", "\xE2\xA6\xB7", 4, 3},
+	{"operp", "\xE2\xA6\xB9", 5, 3},
+	{"oplus", "\xE2\x8A\x95", 5, 3},
+	{"or", "\xE2\x88\xA8", 2, 3},
+	{"orarr", "\xE2\x86\xBB", 5, 3},
+	{"ord", "\xE2\xA9\x9D", 3, 3},
+	{"order", "\xE2\x84\xB4", 5, 3},
+	{"orderof", "\xE2\x84\xB4", 7, 3},
+	{"ordf", "\xC2\xAA", 4, 2},
+	{"ordm", "\xC2\xBA", 4, 2},
+	{"origof", "\xE2\x8A\xB6", 6, 3},
+	{"oror", "\xE2\xA9\x96", 4, 3},
+	{"orslope", "\xE2\xA9\x97", 7, 3},
+	{"orv", "\xE2\xA9\x9B", 3, 3},
+	{"oscr", "\xE2\x84\xB4", 4, 3},
+	{"oslash", "\xC3\xB8", 6, 2},
+	{"osol", "\xE2\x8A\x98", 4, 3},
+	{"otilde", "\xC3\xB5", 6, 2},
+	{"otimes", "\xE2\x8A\x97", 6, 3},
+	{"otimesas", "\xE2\xA8\xB6", 8, 3},
+	{"ouml", "\xC3\xB6", 4, 2},
+	{"ovbar", "\xE2\x8C\xBD", 5, 3},
+	{"par", "\xE2\x88\xA5", 3, 3},
+	{"para", "\xC2\xB6", 4, 2},
+	{"parallel", "\xE2\x88\xA5", 8, 3},
+	{"parsim", "\xE2\xAB\xB3", 6, 3},
+	{"parsl", "\xE2\xAB\xBD", 5, 3},
+	{"part", "\xE2\x88\x82", 4, 3},
+	{"pcy", "\xD0\xBF", 3, 2},
+	{"percnt", "\x25", 6, 1},
+	{"period", "\x2E", 6, 1},
+	{"permil", "\xE2\x80\xB0", 6, 3},
+	{"perp", "\xE2\x8A\xA5", 4, 3},
+	{"pertenk", "\xE2\x80\xB1", 7, 3},
+	{"pfr", "\xF0\x9D\x94\xAD", 3, 4},
+	{"phi", "\xCF\x86", 3, 2},
+	{"phiv", "\xCF\x95", 4, 2},
+	{"phmmat", "\xE2\x84\xB3", 6, 3},
+	{"phone", "\xE2\x98\x8E", 5, 3},
+	{"pi", "\xCF\x80", 2, 2},
+	{"pitchfork", "\xE2\x8B\x94", 9, 3},
+	{"piv", "\xCF\x96", 3, 2},
+	{"planck", "\xE2\x84\x8F", 6, 3},
+	{"planckh", "\xE2\x84\x8E", 7, 3},
+	{"plankv", "\xE2\x84\x8F", 6, 3},
+	{"plus", "\x2B", 4, 1},
+	{"plusacir", "\xE2\xA8\xA3", 8, 3},
+	{"plusb", "\xE2\x8A\x9E", 5, 3},
+	{"pluscir", "\xE2\xA8\xA2", 7, 3},
+	{"plusdo", "\xE2\x88\x94", 6, 3},
+	{"plusdu", "\xE2\xA8\xA5", 6, 3},
+	{"pluse", "\xE2\xA9\xB2", 5, 3},
+	{"plusmn", "\xC2\xB1", 6, 2},
+	{"plussim", "\xE2\xA8\xA6", 7, 3},
+	{"plustwo", "\xE2\xA8\xA7", 7, 3},
+	{"pm", "\xC2\xB1", 2, 2},
+	{"pointint", "\xE2\xA8\x95", 8, 3},
+	{"popf", "\xF0\x9D\x95\xA1", 4, 4},
+	{"pound", "\xC2\xA3", 5, 2},
+	{"pr", "\xE2\x89\xBA", 2, 3},
+	{"prE", "\xE2\xAA\xB3", 3, 3},
+	{"prap", "\xE2\xAA\xB7", 4, 3},
+	{"prcue", "\xE2\x89\xBC", 5, 3},
+	{"pre", "\xE2\xAA\xAF", 3, 3},
+	{"prec", "\xE2\x89\xBA", 4, 3},
+	{"precapprox", "\xE2\xAA\xB7", 10, 3},
+	{"preccurlyeq", "\xE2\x89\xBC", 11, 3},
+	{"preceq", "\xE2\xAA\xAF", 6, 3},
+	{"precnapprox", "\xE2\xAA\xB9", 11, 3},
+	{"precneqq", "\xE2\xAA\xB5", 8, 3},
+	{"precnsim", "\xE2\x8B\xA8", 8, 3},
+	{"precsim", "\xE2\x89\xBE", 7, 3},
+	{"prime", "\xE2\x80\xB2", 5, 3},
+	{"primes", "\xE2\x84\x99", 6, 3},
+	{"prnE", "\xE2\xAA\xB5", 4, 3},
+	{"prnap", "\xE2\xAA\xB9", 5, 3},
+	{"prnsim", "\xE2\x8B\xA8", 6, 3},
+	{"prod", "\xE2\x88\x8F", 4, 3},
+	{"profalar", "\xE2\x8C\xAE", 8, 3},
+	{"profline", "\xE2\x8C\x92", 8, 3},
+	{"profsurf", "\xE2\x8C\x93", 8, 3},
+	{"prop", "\xE2\x88\x9D", 4, 3},
+	{"propto", "\xE2\x88\x9D", 6, 3},
+	{"prsim", "\xE2\x89\xBE", 5, 3},
+	{"prurel", "\xE2\x8A\xB0", 6, 3},
+	{"pscr", "\xF0\x9D\x93\x85", 4, 4},
+	{"psi", "\xCF\x88", 3, 2},
+	{"puncsp", "\xE2\x80\x88", 6, 3},
+	{"qfr", "\xF0\x9D\x94\xAE", 3, 4},
+	{"qint", "\xE2\xA8\x8C", 4, 3},
+	{"qopf", "\xF0\x9D\x95\xA2", 4, 4},
+	{"qprime", "\xE2\x81\x97", 6, 3},
+	{"qscr", "\xF0\x9D\x93\x86", 4, 4},
+	{"quaternions", "\xE2\x84\x8D", 11, 3},
+	{"quatint", "\xE2\xA8\x96", 7, 3},
+	{"quest", "\x3F", 5, 1},
+	{"questeq", "\xE2\x89\x9F", 7, 3},
+	{"quot", "\x22", 4, 1},
+	{"rAarr", "\xE2\x87\x9B", 5, 3},
+	{"rArr", "\xE2\x87\x92", 4, 3},
+	{"rAtail", "\xE2\xA4\x9C", 6, 3},
+	{"rBarr", "\xE2\xA4\x8F", 5, 3},
+	{"rHar", "\xE2\xA5\xA4", 4, 3},
+	{"race", "\xE2\x88\xBD\xCC\xB1", 4, 5},
+	{"racute", "\xC5\x95", 6, 2},
+	{"radic", "\xE2\x88\x9A", 5, 3},
+	{"raemptyv", "\xE2\xA6\xB3", 8, 3},
+	{"rang", "\xE2\x9F\xA9", 4, 3},
+	{"rangd", "\xE2\xA6\x92", 5, 3},
+	{"range", "\xE2\xA6\xA5", 5, 3},
+	{"rangle", "\xE2\x9F\xA9", 6, 3},
+	{"raquo", "\xC2\xBB", 5, 2},
+	{"rarr", "\xE2\x86\x92", 4, 3},
+	{"rarrap", "\xE2\xA5\xB5", 6, 3},
+	{"rarrb", "\xE2\x87\xA5", 5, 3},
+	{"rarrbfs", "\xE2\xA4\xA0", 7, 3},
+	{"rarrc", "\xE2\xA4\xB3", 5, 3},
+	{"rarrfs", "\xE2\xA4\x9E", 6, 3},
+	{"rarrhk", "\xE2\x86\xAA", 6, 3},
+	{"rarrlp", "\xE2\x86\xAC", 6, 3},
+	{"rarrpl", "\xE2\xA5\x85", 6, 3},
+	{"rarrsim", "\xE2\xA5\xB4", 7, 3},
+	{"rarrtl", "\xE2\x86\xA3", 6, 3},
+	{"rarrw", "\xE2\x86\x9D", 5, 3},
+	{"ratail", "\xE2\xA4\x9A", 6, 3},
+	{"ratio", "\xE2\x88\xB6", 5, 3},
+	{"rationals", "\xE2\x84\x9A", 9, 3},
+	{"rbarr", "\xE2\xA4\x8D", 5, 3},
+	{"rbbrk", "\xE2\x9D\xB3", 5, 3},
+	{"rbrace", "\x7D", 6, 1},
+	{"rbrack", "\x5D", 6, 1},
+	{"rbrke", "\xE2\xA6\x8C", 5, 3},
+	{"rbrksld", "\xE2\xA6\x8E", 7, 3},
+	{"rbrkslu", "\xE2\xA6\x90", 7, 3},
+	{"rcaron", "\xC5\x99", 6, 2},
+	{"rcedil", "\xC5\x97", 6, 2},
+	{"rceil", "\xE2\x8C\x89", 5, 3},
+	{"rcub", "\x7D", 4, 1},
+	{"rcy", "\xD1\x80", 3, 2},
+	{"rdca", "\xE2\xA4\xB7", 4, 3},
+	{"rdldhar", "\xE2\xA5\xA9", 7, 3},
+	{"rdquo", "\xE2\x80\x9D", 5, 3},
+	{"rdquor", "\xE2\x80\x9D", 6, 3},
+	{"rdsh", "\xE2\x86\xB3", 4, 3},
+	{"real", "\xE2\x84\x9C", 4, 3},
+	{"realine", "\xE2\x84\x9B", 7, 3},
+	{"realpart", "\xE2\x84\x9C", 8, 3},
+	{"reals", "\xE2\x84\x9D", 5, 3},
+	{"rect", "\xE2\x96\xAD", 4, 3},
+	{"reg", "\xC2\xAE", 3, 2},
+	{"rfisht", "\xE2\xA5\xBD", 6, 3},
+	{"rfloor", "\xE2\x8C\x8B", 6, 3},
+	{"rfr", "\xF0\x9D\x94\xAF", 3, 4},
+	{"rhard", "\xE2\x87\x81", 5, 3},
+	{"rharu", "\xE2\x87\x80", 5, 3},
+	{"rharul", "\xE2\xA5\xAC", 6, 3},
+	{"rho", "\xCF\x81", 3, 2},
+	{"rhov", "\xCF\xB1", 4, 2},
+	{"rightarrow", "\xE2\x86\x92", 10, 3},
+	{"rightarrowtail", "\xE2\x86\xA3", 14, 3},
+	{"rightharpoondown", "\xE2\x87\x81", 16, 3},
+	{"rightharpoonup", "\xE2\x87\x80", 14, 3},
+	{"rightleftarrows", "\xE2\x87\x84", 15, 3},
+	{"rightleftharpoons", "\xE2\x87\x8C", 17, 3},
+	{"rightrightarrows", "\xE2\x87\x89", 16, 3},
+	{"rightsquigarrow", "\xE2\x86\x9D", 15, 3},
+	{"rightthreetimes", "\xE2\x8B\x8C", 15, 3},
+	{"ring", "\xCB\x9A", 4, 2},
+	{"risingdotseq", "\xE2\x89\x93", 12, 3},
+	{"rlarr", "\xE2\x87\x84", 5, 3},
+	{"rlhar", "\xE2\x87\x8C", 5, 3},
+	{"rlm", "\xE2\x80\x8F", 3, 3},
+	{"rmoust", "\xE2\x8E\xB1", 6, 3},
+	{"rmoustache", "\xE2\x8E\xB1", 10, 3},
+	{"rnmid", "\xE2\xAB\xAE", 5, 3},
+	{"roang", "\xE2\x9F\xAD", 5, 3},
+	{"roarr", "\xE2\x87\xBE", 5, 3},
+	{"robrk", "\xE2\x9F\xA7", 5, 3},
+	{"ropar", "\xE2\xA6\x86", 5, 3},
+	{"ropf", "\xF0\x9D\x95\xA3", 4, 4},
+	{"roplus", "\xE2\xA8\xAE", 6, 3},
+	{"rotimes", "\xE2\xA8\xB5", 7, 3},
+	{"rpar", "\x29", 4, 1},
+	{"rpargt", "\xE2\xA6\x94", 6, 3},
+	{"rppolint", "\xE2\xA8\x92", 8, 3},
+	{"rrarr", "\xE2\x87\x89", 5, 3},
+	{"rsaquo", "\xE2\x80\xBA", 6, 3},
+	{"rscr", "\xF0\x9D\x93\x87", 4, 4},
+	{"rsh", "\xE2\x86\xB1", 3, 3},
+	{"rsqb", "\x5D", 4, 1},
+	{"rsquo", "\xE2\x80\x99", 5, 3},
+	{"rsquor", "\xE2\x80\x99", 6, 3},
+	{"rthree", "\xE2\x8B\x8C", 6, 3},
+	{"rtimes", "\xE2\x8B\x8A", 6, 3},
+	{"rtri", "\xE2\x96\xB9", 4, 3},
+	{"rtrie", "\xE2\x8A\xB5", 5, 3},
+	{"rtrif", "\xE2\x96\xB8", 5, 3},
+	{"rtriltri", "\xE2\xA7\x8E", 8, 3},
+	{"ruluhar", "\xE2\xA5\xA8", 7, 3},
+	{"rx", "\xE2\x84\x9E", 2, 3},
+	{"sacute", "\xC5\x9B", 6, 2},
+	{"sbquo", "\xE2\x80\x9A", 5, 3},
+	{"sc", "\xE2\x89\xBB", 2, 3},
+	{"scE", "\xE2\xAA\xB4", 3, 3},
+	{"scap", "\xE2\xAA\xB8", 4, 3},
+	{"scaron", "\xC5\xA1", 6, 2},
+	{"sccue", "\xE2\x89\xBD", 5, 3},
+	{"sce", "\xE2\xAA\xB0", 3, 3},
+	{"scedil", "\xC5\x9F", 6, 2},
+	{"scirc", "\xC5\x9D", 5, 2},
+	{"scnE", "\xE2\xAA\xB6", 4, 3},
+	{"scnap", "\xE2\xAA\xBA", 5, 3},
+	{"scnsim", "\xE2\x8B\xA9", 6, 3},
+	{"scpolint", "\xE2\xA8\x93", 8, 3},
+	{"scsim", "\xE2\x89\xBF", 5, 3},
+	{"scy", "\xD1\x81", 3, 2},
+	{"sdot", "\xE2\x8B\x85", 4, 3},
+	{"sdotb", "\xE2\x8A\xA1", 5, 3},
+	{"sdote", "\xE2\xA9\xA6", 5, 3},
+	{"seArr", "\xE2\x87\x98", 5, 3},
+	{"searhk", "\xE2\xA4\xA5", 6, 3},
+	{"searr", "\xE2\x86\x98", 5, 3},
+	{"searrow", "\xE2\x86\x98", 7, 3},
+	{"sect", "\xC2\xA7", 4, 2},
+	{"semi", "\x3B", 4, 1},
+	{"seswar", "\xE2\xA4\xA9", 6, 3},
+	{"setminus", "\xE2\x88\x96", 8, 3},
+	{"setmn", "\xE2\x88\x96", 5, 3},
+	{"sext", "\xE2\x9C\xB6", 4, 3},
+	{"sfr", "\xF0\x9D\x94\xB0", 3, 4},
+	{"sfrown", "\xE2\x8C\xA2", 6, 3},
+	{"sharp", "\xE2\x99\xAF", 5, 3},
+	{"shchcy", "\xD1\x89", 6, 2},
+	{"shcy", "\xD1\x88", 4, 2},
+	{"shortmid", "\xE2\x88\xA3", 8, 3},
+	{"shortparallel", "\xE2\x88\xA5", 13, 3},
+	{"shy", "\xC2\xAD", 3, 2},
+	{"sigma", "\xCF\x83", 5, 2},
+	{"sigmaf", "\xCF\x82", 6, 2},
+	{"sigmav", "\xCF\x82", 6, 2},
+	{"sim", "\xE2\x88\xBC", 3, 3},
+	{"simdot", "\xE2\xA9\xAA", 6, 3},
+	{"sime", "\xE2\x89\x83", 4, 3},
+	{"simeq", "\xE2\x89\x83", 5, 3},
+	{"simg", "\xE2\xAA\x9E", 4, 3},
+	{"simgE", "\xE2\xAA\xA0", 5, 3},
+	{"siml", "\xE2\xAA\x9D", 4, 3},
+	{"simlE", "\xE2\xAA\x9F", 5, 3},
+	{"simne", "\xE2\x89\x86", 5, 3},
+	{"simplus", "\xE2\xA8\xA4", 7, 3},
+	{"simrarr", "\xE2\xA5\xB2", 7, 3},
+	{"slarr", "\xE2\x86\x90", 5, 3},
+	{"smallsetminus", "\xE2\x88\x96", 13, 3},
+	{"smashp", "\xE2\xA8\xB3", 6, 3},
+	{"smeparsl", "\xE2\xA7\xA4", 8, 3},
+	{"smid", "\xE2\x88\xA3", 4, 3},
+	{"smile", "\xE2\x8C\xA3", 5, 3},
+	{"smt", "\xE2\xAA\xAA", 3, 3},
+	{"smte", "\xE2\xAA\xAC", 4, 3},
+	{"smtes", "\xE2\xAA\xAC\xEF\xB8\x80", 5, 6},
+	{"softcy", "\xD1\x8C", 6, 2},
+	{"sol", "\x2F", 3, 1},
+	{"solb", "\xE2\xA7\x84", 4, 3},
+	{"solbar", "\xE2\x8C\xBF", 6, 3},
+	{"sopf", "\xF0\x9D\x95\xA4", 4, 4},
+	{"spades", "\xE2\x99\xA0", 6, 3},
+	{"spadesuit", "\xE2\x99\xA0", 9, 3},
+	{"spar", "\xE2\x88\xA5", 4, 3},
+	{"sqcap", "\xE2\x8A\x93", 5, 3},
+	{"sqcaps", "\xE2\x8A\x93\xEF\xB8\x80", 6, 6},
+	{"sqcup", "\xE2\x8A\x94", 5, 3},
+	{"sqcups", "\xE2\x8A\x94\xEF\xB8\x80", 6, 6},
+	{"sqsub", "\xE2\x8A\x8F", 5, 3},
+	{"sqsube", "\xE2\x8A\x91", 6, 3},
+	{"sqsubset", "\xE2\x8A\x8F", 8, 3},
+	{"sqsubseteq", "\xE2\x8A\x91", 10, 3},
+	{"sqsup", "\xE2\x8A\x90", 5, 3},
+	{"sqsupe", "\xE2\x8A\x92", 6, 3},
+	{"sqsupset", "\xE2\x8A\x90", 8, 3},
+	{"sqsupseteq", "\xE2\x8A\x92", 10, 3},
+	{"squ", "\xE2\x96\xA1", 3, 3},
+	{"square", "\xE2\x96\xA1", 6, 3},
+	{"squarf", "\xE2\x96\xAA", 6, 3},
+	{"squf", "\xE2\x96\xAA", 4, 3},
+	{"srarr", "\xE2\x86\x92", 5, 3},
+	{"sscr", "\xF0\x9D\x93\x88", 4, 4},
+	{"ssetmn", "\xE2\x88\x96", 6, 3},
+	{"ssmile", "\xE2\x8C\xA3", 6, 3},
+	{"sstarf", "\xE2\x8B\x86", 6, 3},
+	{"star", "\xE2\x98\x86", 4, 3},
+	{"starf", "\xE2\x98\x85", 5, 3},
+	{"straightepsilon", "\xCF\xB5", 15, 2},
+	{"straightphi", "\xCF\x95", 11, 2},
+	{"strns", "\xC2\xAF", 5, 2},
+	{"sub", "\xE2\x8A\x82", 3, 3},
+	{"subE", "\xE2\xAB\x85", 4, 3},
+	{"subdot", "\xE2\xAA\xBD", 6, 3},
+	{"sube", "\xE2\x8A\x86", 4, 3},
+	{"subedot", "\xE2\xAB\x83", 7, 3},
+	{"submult", "\xE2\xAB\x81", 7, 3},
+	{"subnE", "\xE2\xAB\x8B", 5, 3},
+	{"subne", "\xE2\x8A\x8A", 5, 3},
+	{"subplus", "\xE2\xAA\xBF", 7, 3},
+	{"subrarr", "\xE2\xA5\xB9", 7, 3},
+	{"subset", "\xE2\x8A\x82", 6, 3},
+	{"subseteq", "\xE2\x8A\x86", 8, 3},
+	{"subseteqq", "\xE2\xAB\x85", 9, 3},
+	{"subsetneq", "\xE2\x8A\x8A", 9, 3},
+	{"subsetneqq", "\xE2\xAB\x8B", 10, 3},
+	{"subsim", "\xE2\xAB\x87", 6, 3},
+	{"subsub", "\xE2\xAB\x95", 6, 3},
+	{"subsup", "\xE2\xAB\x93", 6, 3},
+	{"succ", "\xE2\x89\xBB", 4, 3},
+	{"succapprox", "\xE2\xAA\xB8", 10, 3},
+	{"succcurlyeq", "\xE2\x89\xBD", 11, 3},
+	{"succeq", "\xE2\xAA\xB0", 6, 3},
+	{"succnapprox", "\xE2\xAA\xBA", 11, 3},
+	{"succneqq", "\xE2\xAA\xB6", 8, 3},
+	{"succnsim", "\xE2\x8B\xA9", 8, 3},
+	{"succsim", "\xE2\x89\xBF", 7, 3},
+	{"sum", "\xE2\x88\x91", 3, 3},
+	{"sung", "\xE2\x99\xAA", 4, 3},
+	{"sup", "\xE2\x8A\x83", 3, 3},
+	{"sup1", "\xC2\xB9", 4, 2},
+	{"sup2", "\xC2\xB2", 4, 2},
+	{"sup3", "\xC2\xB3", 4, 2},
+	{"supE", "\xE2\xAB\x86", 4, 3},
+	{"supdot", "\xE2\xAA\xBE", 6, 3},
+	{"supdsub", "\xE2\xAB\x98", 7, 3},
+	{"supe", "\xE2\x8A\x87", 4, 3},
+	{"supedot", "\xE2\xAB\x84", 7, 3},
+	{"suphsol", "\xE2\x9F\x89", 7, 3},
+	{"suphsub", "\xE2\xAB\x97", 7, 3},
+	{"suplarr", "\xE2\xA5\xBB", 7, 3},
+	{"supmult", "\xE2\xAB\x82", 7, 3},
+	{"supnE", "\xE2\xAB\x8C", 5, 3},
+	{"supne", "\xE2\x8A\x8B", 5, 3},
+	{"supplus", "\xE2\xAB\x80", 7, 3},
+	{"supset", "\xE2\x8A\x83", 6, 3},
+	{"supseteq", "\xE2\x8A\x87", 8, 3},
+	{"supseteqq", "\xE2\xAB\x86", 9, 3},
+	{"supsetneq", "\xE2\x8A\x8B", 9, 3},
+	{"supsetneqq", "\xE2\xAB\x8C", 10, 3},
+	{"supsim", "\xE2\xAB\x88", 6, 3},
+	{"supsub", "\xE2\xAB\x94", 6, 3},
+	{"supsup", "\xE2\xAB\x96", 6, 3},
+	{"swArr", "\xE2\x87\x99", 5, 3},
+	{"swarhk", "\xE2\xA4\xA6", 6, 3},
+	{"swarr", "\xE2\x86\x99", 5, 3},
+	{"swarrow", "\xE2\x86\x99", 7, 3},
+	{"swnwar", "\xE2\xA4\xAA", 6, 3},
+	{"szlig", "\xC3\x9F", 5, 2},
+	{"target", "\xE2\x8C\x96", 6, 3},
+	{"tau", "\xCF\x84", 3, 2},
+	{"tbrk", "\xE2\x8E\xB4", 4, 3},
+	{"tcaron", "\xC5\xA5", 6, 2},
+	{"tcedil", "\xC5\xA3", 6, 2},
+	{"tcy", "\xD1\x82", 3, 2},
+	{"tdot", "\xE2\x83\x9B", 4, 3},
+	{"telrec", "\xE2\x8C\x95", 6, 3},
+	{"tfr", "\xF0\x9D\x94\xB1", 3, 4},
+	{"there4", "\xE2\x88\xB4", 6, 3},
+	{"therefore", "\xE2\x88\xB4", 9, 3},
+	{"theta", "\xCE\xB8", 5, 2},
+	{"thetasym", "\xCF\x91", 8, 2},
+	{"thetav", "\xCF\x91", 6, 2},
+	{"thickapprox", "\xE2\x89\x88", 11, 3},
+	{"thicksim", "\xE2\x88\xBC", 8, 3},
+	{"thinsp", "\xE2\x80\x89", 6, 3},
+	{"thkap", "\xE2\x89\x88", 5, 3},
+	{"thksim", "\xE2\x88\xBC", 6, 3},
+	{"thorn", "\xC3\xBE", 5, 2},
+	{"tilde", "\xCB\x9C", 5, 2},
+	{"times", "\xC3\x97", 5, 2},
+	{"timesb", "\xE2\x8A\xA0", 6, 3},
+	{"timesbar", "\xE2\xA8\xB1", 8, 3},
+	{"timesd", "\xE2\xA8\xB0", 6, 3},
+	{"tint", "\xE2\x88\xAD", 4, 3},
+	{"toea", "\xE2\xA4\xA8", 4, 3},
+	{"top", "\xE2\x8A\xA4", 3, 3},
+	{"topbot", "\xE2\x8C\xB6", 6, 3},
+	{"topcir", "\xE2\xAB\xB1", 6, 3},
+	{"topf", "\xF0\x9D\x95\xA5", 4, 4},
+	{"topfork", "\xE2\xAB\x9A", 7, 3},
+	{"tosa", "\xE2\xA4\xA9", 4, 3},
+	{"tprime", "\xE2\x80\xB4", 6, 3},
+	{"trade", "\xE2\x84\xA2", 5, 3},
+	{"triangle", "\xE2\x96\xB5", 8, 3},
+	{"triangledown", "\xE2\x96\xBF", 12, 3},
+	{"triangleleft", "\xE2\x97\x83", 12, 3},
+	{"trianglelefteq", "\xE2\x8A\xB4", 14, 3},
+	{"triangleq", "\xE2\x89\x9C", 9, 3},
+	{"triangleright", "\xE2\x96\xB9", 13, 3},
+	{"trianglerighteq", "\xE2\x8A\xB5", 15, 3},
+	{"tridot", "\xE2\x97\xAC", 6, 3},
+	{"trie", "\xE2\x89\x9C", 4, 3},
+	{"triminus", "\xE2\xA8\xBA", 8, 3},
+	{"triplus", "\xE2\xA8\xB9", 7, 3},
+	{"trisb", "\xE2\xA7\x8D", 5, 3},
+	{"tritime", "\xE2\xA8\xBB", 7, 3},
+	{"trpezium", "\xE2\x8F\xA2", 8, 3},
+	{"tscr", "\xF0\x9D\x93\x89", 4, 4},
+	{"tscy", "\xD1\x86", 4, 2},
+	{"tshcy", "\xD1\x9B", 5, 2},
+	{"tstrok", "\xC5\xA7", 6, 2},
+	{"twixt", "\xE2\x89\xAC", 5, 3},
+	{"twoheadleftarrow", "\xE2\x86\x9E", 16, 3},
+	{"twoheadrightarrow", "\xE2\x86\xA0", 17, 3},
+	{"uArr", "\xE2\x87\x91", 4, 3},
+	{"uHar", "\xE2\xA5\xA3", 4, 3},
+	{"uacute", "\xC3\xBA", 6, 2},
+	{"uarr", "\xE2\x86\x91", 4, 3},
+	{"ubrcy", "\xD1\x9E", 5, 2},
+	{"ubreve", "\xC5\xAD", 6, 2},
+	{"ucirc", "\xC3\xBB", 5, 2},
+	{"ucy", "\xD1\x83", 3, 2},
+	{"udarr", "\xE2\x87\x85", 5, 3},
+	{"udblac", "\xC5\xB1", 6, 2},
+	{"udhar", "\xE2\xA5\xAE", 5, 3},
+	{"ufisht", "\xE2\xA5\xBE", 6, 3},
+	{"ufr", "\xF0\x9D\x94\xB2", 3, 4},
+	{"ugrave", "\xC3\xB9", 6, 2},
+	{"uharl", "\xE2\x86\xBF", 5, 3},
+	{"uharr", "\xE2\x86\xBE", 5, 3},
+	{"uhblk", "\xE2\x96\x80", 5, 3},
+	{"ulcorn", "\xE2\x8C\x9C", 6, 3},
+	{"ulcorner", "\xE2\x8C\x9C", 8, 3},
+	{"ulcrop", "\xE2\x8C\x8F", 6, 3},
+	{"ultri", "\xE2\x97\xB8", 5, 3},
+	{"umacr", "\xC5\xAB", 5, 2},
+	{"uml", "\xC2\xA8", 3, 2},
+	{"uogon", "\xC5\xB3", 5, 2},
+	{"uopf", "\xF0\x9D\x95\xA6", 4, 4},
+	{"uparrow", "\xE2\x86\x91", 7, 3},
+	{"updownarrow", "\xE2\x86\x95", 11, 3},
+	{"upharpoonleft", "\xE2\x86\xBF", 13, 3},
+	{"upharpoonright", "\xE2\x86\xBE", 14, 3},
+	{"uplus", "\xE2\x8A\x8E", 5, 3},
+	{"upsi", "\xCF\x85", 4, 2},
+	{"upsih", "\xCF\x92", 5, 2},
+	{"upsilon", "\xCF\x85", 7, 2},
+	{"upuparrows", "\xE2\x87\x88", 10, 3},
+	{"urcorn", "\xE2\x8C\x9D", 6, 3},
+	{"urcorner", "\xE2\x8C\x9D", 8, 3},
+	{"urcrop", "\xE2\x8C\x8E", 6, 3},
+	{"uring", "\xC5\xAF", 5, 2},
+	{"urtri", "\xE2\x97\xB9", 5, 3},
+	{"uscr", "\xF0\x9D\x93\x8A", 4, 4},
+	{"utdot", "\xE2\x8B\xB0", 5, 3},
+	{"utilde", "\xC5\xA9", 6, 2},
+	{"utri", "\xE2\x96\xB5", 4, 3},
+	{"utrif", "\xE2\x96\xB4", 5, 3},
+	{"uuarr", "\xE2\x87\x88", 5, 3},
+	{"uuml", "\xC3\xBC", 4, 2},
+	{"uwangle", "\xE2\xA6\xA7", 7, 3},
+	{"vArr", "\xE2\x87\x95", 4, 3},
+	{"vBar", "\xE2\xAB\xA8", 4, 3},
+	{"vBarv", "\xE2\xAB\xA9", 5, 3},
+	{"vDash", "\xE2\x8A\xA8", 5, 3},
+	{"vangrt", "\xE2\xA6\x9C", 6, 3},
+	{"varepsilon", "\xCF\xB5", 10, 2},
+	{"varkappa", "\xCF\xB0", 8, 2},
+	{"varnothing", "\xE2\x88\x85", 10, 3},
+	{"varphi", "\xCF\x95", 6, 2},
+	{"varpi", "\xCF\x96", 5, 2},
+	{"varpropto", "\xE2\x88\x9D", 9, 3},
+	{"varr", "\xE2\x86\x95", 4, 3},
+	{"varrho", "\xCF\xB1", 6, 2},
+	{"varsigma", "\xCF\x82", 8, 2},
+	{"varsubsetneq", "\xE2\x8A\x8A\xEF\xB8\x80", 12, 6},
+	{"varsubsetneqq", "\xE2\xAB\x8B\xEF\xB8\x80", 13, 6},
+	{"varsupsetneq", "\xE2\x8A\x8B\xEF\xB8\x80", 12, 6},
+	{"varsupsetneqq", "\xE2\xAB\x8C\xEF\xB8\x80", 13, 6},
+	{"vartheta", "\xCF\x91", 8, 2},
+	{"vartriangleleft", "\xE2\x8A\xB2", 15, 3},
+	{"vartriangleright", "\xE2\x8A\xB3", 16, 3},
+	{"vcy", "\xD0\xB2", 3, 2},
+	{"vdash", "\xE2\x8A\xA2", 5, 3},
+	{"vee", "\xE2\x88\xA8", 3, 3},
+	{"veebar", "\xE2\x8A\xBB", 6, 3},
+	{"veeeq", "\xE2\x89\x9A", 5, 3},
+	{"vellip", "\xE2\x8B\xAE", 6, 3},
+	{"verbar", "\x7C", 6, 1},
+	{"vert", "\x7C", 4, 1},
+	{"vfr", "\xF0\x9D\x94\xB3", 3, 4},
+	{"vltri", "\xE2\x8A\xB2", 5, 3},
+	{"vnsub", "\xE2\x8A\x82\xE2\x83\x92", 5, 6},
+	{"vnsup", "\xE2\x8A\x83\xE2\x83\x92", 5, 6},
+	{"vopf", "\xF0\x9D\x95\xA7", 4, 4},
+	{"vprop", "\xE2\x88\x9D", 5, 3},
+	{"vrtri", "\xE2\x8A\xB3", 5, 3},
+	{"vscr", "\xF0\x9D\x93\x8B", 4, 4},
+	{"vsubnE", "\xE2\xAB\x8B\xEF\xB8\x80", 6, 6},
+	{"vsubne", "\xE2\x8A\x8A\xEF\xB8\x80", 6, 6},
+	{"vsupnE", "\xE2\xAB\x8C\xEF\xB8\x80", 6, 6},
+	{"vsupne", "\xE2\x8A\x8B\xEF\xB8\x80", 6, 6},
+	{"vzigzag", "\xE2\xA6\x9A", 7, 3},
+	{"wcirc", "\xC5\xB5", 5, 2},
+	{"wedbar", "\xE2\xA9\x9F", 6, 3},
+	{"wedge", "\xE2\x88\xA7", 5, 3},
+	{"wedgeq", "\xE2\x89\x99", 6, 3},
+	{"weierp", "\xE2\x84\x98", 6, 3},
+	{"wfr", "\xF0\x9D\x94\xB4", 3, 4},
+	{"wopf", "\xF0\x9D\x95\xA8", 4, 4},
+	{"wp", "\xE2\x84\x98", 2, 3},
+	{"wr", "\xE2\x89\x80", 2, 3},
+	{"wreath", "\xE2\x89\x80", 6, 3},
+	{"wscr", "\xF0\x9D\x93\x8C", 4, 4},
+	{"xcap", "\xE2\x8B\x82", 4, 3},
+	{"xcirc", "\xE2\x97\xAF", 5, 3},
+	{"xcup", "\xE2\x8B\x83", 4, 3},
+	{"xdtri", "\xE2\x96\xBD", 5, 3},
+	{"xfr", "\xF0\x9D\x94\xB5", 3, 4},
+	{"xhArr", "\xE2\x9F\xBA", 5, 3},
+	{"xharr", "\xE2\x9F\xB7", 5, 3},
+	{"xi", "\xCE\xBE", 2, 2},
+	{"xlArr", "\xE2\x9F\xB8", 5, 3},
+	{"xlarr", "\xE2\x9F\xB5", 5, 3},
+	{"xmap", "\xE2\x9F\xBC", 4, 3},
+	{"xnis", "\xE2\x8B\xBB", 4, 3},
+	{"xodot", "\xE2\xA8\x80", 5, 3},
+	{"xopf", "\xF0\x9D\x95\xA9", 4, 4},
+	{"xoplus", "\xE2\xA8\x81", 6, 3},
+	{"xotime", "\xE2\xA8\x82", 6, 3},
+	{"xrArr", "\xE2\x9F\xB9", 5, 3},
+	{"xrarr", "\xE2\x9F\xB6", 5, 3},
+	{"xscr", "\xF0\x9D\x93\x8D", 4, 4},
+	{"xsqcup", "\xE2\xA8\x86", 6, 3},
+	{"xuplus", "\xE2\xA8\x84", 6, 3},
+	{"xutri", "\xE2\x96\xB3", 5, 3},
+	{"xvee", "\xE2\x8B\x81", 4, 3},
+	{"xwedge", "\xE2\x8B\x80", 6, 3},
+	{"yacute", "\xC3\xBD", 6, 2},
+	{"yacy", "\xD1\x8F", 4, 2},
+	{"ycirc", "\xC5\xB7", 5, 2},
+	{"ycy", "\xD1\x8B", 3, 2},
+	{"yen", "\xC2\xA5", 3, 2},
+	{"yfr", "\xF0\x9D\x94\xB6", 3, 4},
+	{"yicy", "\xD1\x97", 4, 2},
+	{"yopf", "\xF0\x9D\x95\xAA", 4, 4},
+	{"yscr", "\xF0\x9D\x93\x8E", 4, 4},
+	{"yucy", "\xD1\x8E", 4, 2},
+	{"yuml", "\xC3\xBF", 4, 2},
+	{"zacute", "\xC5\xBA", 6, 2},
+	{"zcaron", "\xC5\xBE", 6, 2},
+	{"zcy", "\xD0\xB7", 3, 2},
+	{"zdot", "\xC5\xBC", 4, 2},
+	{"zeetrf", "\xE2\x84\xA8", 6, 3},
+	{"zeta", "\xCE\xB6", 4, 2},
+	{"zfr", "\xF0\x9D\x94\xB7", 3, 4},
+	{"zhcy", "\xD0\xB6", 4, 2},
+	{"zigrarr", "\xE2\x87\x9D", 7, 3},
+	{"zopf", "\xF0\x9D\x95\xAB", 4, 4},
+	{"zscr", "\xF0\x9D\x93\x8F", 4, 4},
+	{"zwj", "\xE2\x80\x8D", 3, 3},
+	{"zwnj", "\xE2\x80\x8C", 4, 3},
+};
+
+#endif /* ZEND_MARKUP_ENTITIES_H */
diff --git a/Zend/zend_markup_entities_gen.php b/Zend/zend_markup_entities_gen.php
new file mode 100644
index 000000000000..d9efd2f9dd07
--- /dev/null
+++ b/Zend/zend_markup_entities_gen.php
@@ -0,0 +1,108 @@
+<?php
+
+/**
+ * Generates zend_markup_entities.h - the named character reference table used
+ * by native markup text/attribute decoding.
+ *
+ * Usage: php Zend/zend_markup_entities_gen.php > Zend/zend_markup_entities.h
+ *
+ * The source data is ext/standard/html_tables/ents_html5.txt - the same
+ * WHATWG HTML5 named-reference table that feeds html_entity_decode(), so
+ * there is a single copy of the data in the tree. The HTML standard
+ * guarantees this list is frozen - no named entity will ever be added - so
+ * the generated header only changes if this generator does. The table
+ * contains only the canonical semicolon-terminated forms: markup requires
+ * the well-formed "&name;" spelling and treats legacy forms like "&amp"
+ * as literal text.
+ */
+
+$source = $argv[1] ?? __DIR__ . '/../ext/standard/html_tables/ents_html5.txt';
+
+$lines = @file($source, FILE_IGNORE_NEW_LINES | FILE_SKIP_EMPTY_LINES);
+if ($lines === false) {
+    fwrite(STDERR, "cannot read {$source}\n");
+    exit(1);
+}
+
+function utf8_bytes(int $cp): string
+{
+    if ($cp < 0x80) {
+        return chr($cp);
+    } elseif ($cp < 0x800) {
+        return chr(0xC0 | ($cp >> 6)) . chr(0x80 | ($cp & 0x3F));
+    } elseif ($cp < 0x10000) {
+        return chr(0xE0 | ($cp >> 12)) . chr(0x80 | (($cp >> 6) & 0x3F)) . chr(0x80 | ($cp & 0x3F));
+    }
+    return chr(0xF0 | ($cp >> 18)) . chr(0x80 | (($cp >> 12) & 0x3F))
+        . chr(0x80 | (($cp >> 6) & 0x3F)) . chr(0x80 | ($cp & 0x3F));
+}
+
+$entities = [];
+foreach ($lines as $line) {
+    $parts = explode(' ', trim($line));
+    $name = array_shift($parts);
+    if (!preg_match('/^[A-Za-z][A-Za-z0-9]*$/', $name)) {
+        fwrite(STDERR, "unexpected entity name: $name\n");
+        exit(1);
+    }
+    if ($parts === []) {
+        fwrite(STDERR, "no codepoints for entity: $name\n");
+        exit(1);
+    }
+    $utf8 = '';
+    foreach ($parts as $hex) {
+        if (!preg_match('/^[0-9A-F]{1,6}$/', $hex)) {
+            fwrite(STDERR, "unexpected codepoint \"$hex\" for entity: $name\n");
+            exit(1);
+        }
+        $utf8 .= utf8_bytes(hexdec($hex));
+    }
+    $entities[$name] = $utf8;
+}
+
+/* Byte order, matching the C-side memcmp binary search. */
+ksort($entities, SORT_STRING);
+
+$maxName = max(array_map('strlen', array_keys($entities)));
+$maxUtf8 = max(array_map('strlen', $entities));
+$count = count($entities);
+
+echo <<<EOT
+/* This is a generated file - edit Zend/zend_markup_entities_gen.php instead.
+ * Source data: ext/standard/html_tables/ents_html5.txt (the WHATWG HTML5
+ * named-reference table, frozen by the HTML standard; also feeds
+ * html_entity_decode()). Canonical semicolon-terminated forms only; sorted
+ * by name in byte order for bsearch. */
+
+#ifndef ZEND_MARKUP_ENTITIES_H
+#define ZEND_MARKUP_ENTITIES_H
+
+typedef struct _zend_markup_entity {
+	const char *name;   /* without the leading '&' and trailing ';' */
+	const char *utf8;   /* replacement text, UTF-8 */
+	uint8_t name_len;
+	uint8_t utf8_len;
+} zend_markup_entity;
+
+#define ZEND_MARKUP_ENTITY_COUNT {$count}
+#define ZEND_MARKUP_ENTITY_MAX_NAME {$maxName}
+#define ZEND_MARKUP_ENTITY_MAX_UTF8 {$maxUtf8}
+
+static const zend_markup_entity zend_markup_entities[ZEND_MARKUP_ENTITY_COUNT] = {
+
+EOT;
+
+foreach ($entities as $name => $utf8) {
+    $hex = '';
+    foreach (str_split($utf8) as $byte) {
+        $hex .= sprintf('\\x%02X', ord($byte));
+    }
+    printf("\t{\"%s\", \"%s\", %d, %d},\n", $name, $hex, strlen($name), strlen($utf8));
+}
+
+echo <<<EOT
+};
+
+#endif /* ZEND_MARKUP_ENTITIES_H */
+
+EOT;
diff --git a/configure.ac b/configure.ac
index 9014869fb94e..bd8e66ea9d10 100644
--- a/configure.ac
+++ b/configure.ac
@@ -1781,6 +1781,7 @@ PHP_ADD_SOURCES([Zend], m4_normalize([
     zend_lazy_objects.c
     zend_list.c
     zend_llist.c
+    zend_markup.c
     zend_max_execution_timer.c
     zend_multibyte.c
     zend_object_handlers.c
diff --git a/ext/html/CREDITS b/ext/html/CREDITS
new file mode 100644
index 000000000000..f4bf41ea7d15
--- /dev/null
+++ b/ext/html/CREDITS
@@ -0,0 +1,2 @@
+Native Markup (Html)
+Liam Hammett
diff --git a/ext/html/RFC.md b/ext/html/RFC.md
new file mode 100644
index 000000000000..e1c0575d02a0
--- /dev/null
+++ b/ext/html/RFC.md
@@ -0,0 +1,630 @@
+# Native Markup Expressions (JSX-style syntax)
+
+## Introduction
+
+PHP began as a templating language - code embedded *inside* HTML. As the language and its ecosystem have matured, the inverse has become just as desirable: embedding HTML *inside* PHP, as a first-class value you can compose, return, and pass around.
+
+Yet PHP still has no native way to do it. Today authors choose between:
+
+* **Inline HTML** (`?> <h1><?= $x ?></h1> <?php`) - output-only: it cannot be captured as a value without output buffering, offers no composition, does not escape, and the tag-soup syntax is verbose and hard to read.
+* **String concatenation / heredocs** - no escaping, no structure, error-prone.
+* **Userland template engines** (Blade, Twig, Latte) - powerful, but each requires a separate template dialect and files, a compilation step, a parser written in PHP, and its own third-party IDE/tooling support.
+
+This RFC proposes a **native markup expression syntax**, inspired by JSX, that produces an in-memory tree of objects which renders to safely-escaped HTML. Markup becomes a *value*: it can be returned, passed to functions, stored, and composed.
+
+```php
+class Greeting implements Html\Htmlable
+{
+    public function __construct(public string $name, public string $type) {}
+
+    public function toHtml(): Html\Htmlable
+    {
+        return <>
+            <h1 class="title">Hello, {$this->name ?: ucfirst($this->type)}!</h1>
+            <p>Welcome to PHP, where markup is a first-class expression.</p>
+        </>;
+    }
+}
+
+echo <Greeting name="Rasmus" type="guest" />; // prints the rendered HTML, dynamic values escaped
+```
+
+Despite appearances, this is not a new template language grafted onto PHP - the syntax is **pure compile-time sugar**. Every markup expression lowers, during compilation, to a plain `new` expression:
+
+```php
+// The new syntax...
+$html = <button class="btn">Sign in</button>;
+
+// ...compiles to exactly this - same AST, same opcodes:
+$html = new \Html\Element('button', ['class' => 'btn'], ['Sign in']);
+```
+
+Nothing downstream of the parser changes, and markup obeys the expression semantics every PHP developer already knows.
+
+The two headline benefits over every existing option are **composition** (components, attributes, slots) and **escape-by-default safety** - neither of which PHP's existing markup facilities provide. And because markup is ordinary PHP code rather than a string dialect, static analysis reaches inside it: component props are named arguments checked against real signatures, so templates become type-checkable end-to-end.
+
+### Why this is worth doing
+
+Generating HTML is not a niche PHP task - it is arguably *the* PHP task, and essentially every major framework has independently built the same answer to it: an escape-by-default, composable template engine. Their adoption is enormous - on Packagist, `laravel/framework` (Blade) has over **540 million** installs and `twig/twig` over **460 million**, before counting Latte, Smarty, Plates, or hand-rolled templates that never appear in a dependency graph.
+
+That every engine converged on the same two features is strong evidence the need is real and the language does not meet it: developers reach for a third-party compiler, a separate dialect, and a build step to obtain what the runtime could provide natively. And escape-by-default is no mere convenience - cross-site scripting has sat in the OWASP Top 10 for its entire existence, and automatic HTML escaping is one of the disciplines that prevents it.
+
+## History
+
+This idea is not new - PHP is where it started. Around 2010, Facebook built **XHP**, a PHP extension that made XML/HTML fragments valid PHP expressions with automatic escaping - `<a href={$url}>Link</a>` as a real value - and it survives today as a native feature of Hack. **JSX was born directly out of XHP**, and has since become *the* way most frontend developers write user interfaces. The pattern has proven itself at ecosystem scale; this RFC brings it home.
+
+The approach has surfaced in various forms many times over the years without a formal proposal; discussions about "automatic template escaping" resulted in arguments that "XHP really is the right solution for this problem," though that also raised the central objection - escaping is context-dependent (HTML vs URL vs JS vs CSS) - which this RFC answers by scoping escaping to HTML context only (see Escape-by-default).
+
+### Why core, and not an extension
+
+An obvious question - especially given the XHP precedent - is whether this could be proven out as a PECL extension first. It cannot, for one technical reason and one practical one.
+
+Technically, markup must begin at a bare `<` in operand position, and telling that apart from the comparison and shift operators requires the scanner change described under Parsing - state no extension can reach. The only route open to an extension is rewriting source text before compilation (the original XHP extension's approach), which shifts line numbers in errors and stack traces and leaves the raw file something `token_get_all()` - and therefore every tool built on it - cannot tokenize.
+
+Practically, a *syntax* lives or dies by its ecosystem. Code using an extension-only syntax cannot be reasonably published to Packagist - it is a parse error on any install without the extension - and no IDE, formatter, or static analyser updates its grammar for syntax that may not exist on a given machine. That chicken-and-egg is part of where XHP for PHP stalled, while the same feature thrived in Hack, where it is part of the language. Shipping in core is what makes markup part of PHP itself: parsers, IDEs, and analysis tools implement it once, and every developer's markup gets the same highlighting, formatting, and static analysis their ordinary code already enjoys.
+
+## Goals & Non-Goals
+
+The goal of this RFC is a native, ergonomic syntax for building HTML - the output format the overwhelming majority of PHP produces - with escaping and composition built in.
+
+This RFC is deliberately narrower than XHP: it targets **HTML specifically**, not general XML. That choice is visible throughout - escaping uses `htmlspecialchars`; void elements serialize as HTML5 (`<br>`, not `<br/>`); text and attribute handling follow HTML, not XML, semantics. There is no XML namespace support, no CDATA, no DTD, and no requirement that output be well-formed XML. This keeps the surface small and the output aimed at the one thing PHP overwhelmingly produces: web pages. Emitting XML (RSS, SVG, SOAP) remains the job of the existing DOM / `XMLWriter` APIs and is out of scope.
+
+Semantic validation of attribute *values* is also not a goal - a `javascript:` URL in `href`/`src` escapes cleanly yet is not blocked: sometimes it is intentional, and the policy is the application's to set. (Latte nullifies such URLs and React warns; a framework can enforce the same here via a component decorator or userland wrapper.) Attribute and tag *names*, by contrast, are always validated - see Escape-by-default.
+
+The aim, in short: enough syntax to make HTML a first-class concern of PHP, with the extension points for frameworks to customize behaviour, and room to grow without breaking backward compatibility (see Future Scope).
+
+## Proposal
+
+### 1. A markup expression that evaluates to an object
+
+The core proposal is that a markup expression evaluates to an instance of a built-in type implementing `Html\Htmlable`. It is **not** a string - but casting it to one will return a string value.
+
+This is the JSX model (elements are objects, strings appear only after rendering) and is what makes composition and a single, central escaping step possible.
+
+#### Desugaring at a glance
+
+Every construct in this proposal lowers the same way - at compile time, to a `new` expression or a function call, behaviour PHP already supports well; no other part of the engine changes.
+
+```php
+// Attributes: literal, ={expr}, bare boolean, {...spread}     (see Attributes)
+<a href={$url} class="btn">{$label}</a>
+// → new \Html\Element('a', ['href' => $url, 'class' => 'btn'], [$label])
+
+// Fragments group children with no wrapper element            (see Syntax structure)
+<><h1>{$title}</h1><input {...$attrs} required /></>
+// → new \Html\Fragment([
+//       new \Html\Element('h1', [], [$title]),
+//       new \Html\Element('input', [...$attrs, 'required' => true], []),
+//   ])
+
+// Components dispatch through Html\render_component()         (see Tags)
+<Card title="Hi" />
+// → \Html\render_component(Card::class, ['title' => 'Hi'])
+
+// Component body → slot; extra regions are markup-valued props   (see Children & slots)
+<Layout theme="dark" header={<h1>Title</h1>}>
+    <p>Body content.</p>
+</Layout>
+// → \Html\render_component(
+//       Layout::class,                          // resolved as a class name string
+//       ['theme' => 'dark',                     // props → named arguments
+//        'header' => new \Html\Element('h1', [], ['Title'])],
+//       new \Html\Fragment([/* <p>...</p> */]),   // body slot
+//   )
+
+// Dynamic tags: the value classifies at runtime                (see Tags)
+<$tag class="box">{$content}</$tag>
+// → \Html\render_dynamic($tag, ['class' => 'box'], [$content])
+```
+
+Two properties fall directly out of this lowering. Markup is **zero-cost sugar** - writing the objects by hand produces the same AST and opcodes. And markup obeys **ordinary expression semantics** - attributes and children are argument expressions, evaluated eagerly, scoped and typed like any other PHP code.
+
+Every lowering in this document can be reproduced on the reference implementation with no extra tooling: `php -d zend.assertions=1 -r 'assert(false && <markup />);'` prints the desugared form in the assertion message.
+
+### 2. Escape-by-default
+
+This is a *templating* feature, and like every major PHP template engine (Blade, Twig, Latte) it **escapes by default**:
+
+* Interpolations `{$expr}` and **attribute values** are escaped with `htmlspecialchars($v, ENT_QUOTES | ENT_SUBSTITUTE | ENT_HTML401)` - like `htmlspecialchars()` itself, the charset comes from ini `default_charset` (UTF-8 by default), so non-UTF-8 applications keep working.
+* Any value implementing `Html\Htmlable` (including elements and fragments) passes through **un-escaped** - it is already assumed to be safe HTML.
+* The explicit, greppable opt-out for trusted raw strings is `Html\raw($trustedString)`, which returns an `Html\Htmlable`. `Html\escape($string)` is also provided.
+
+Escaping is **HTML-context only**. URL/JS/CSS-context escaping is explicitly **out of scope** and remains the author's responsibility. Full context-aware escaping is noted as Future Scope.
+
+A single escaping context is sound here in a way it is not for string-template engines, because there is no context to *detect*:
+
+* The grammar admits dynamic data in few positions - child content and attribute values - each escaped by one fixed rule (attribute values are always serialized double-quoted; no unquoted output form exists).
+* Dynamically-supplied *names* (spread keys, `new Element($tag)`) are **validated** and can throw a runtime exception, not escaped - an invalid name is a `ValueError`, so a name can never break out of the markup.
+* `<script>`/`<style>` get no raw-text mode: interpolated content there is HTML-escaped like any other child, so `</script>` breakout is inexpressible.
+
+### 3. Tags: HTML elements vs components
+
+Dispatch is purely **syntactic** (the compiler cannot know runtime types):
+
+| Tag form | Meaning |
+|---|---|
+| `<div>`, `<my-widget>` (lowercase / hyphenated) | literal HTML element → `Html\Element` |
+| `<Card>` (bare, capitalized) | a **component** - resolved as a class name honoring `use` / namespace |
+| `<App\Card>`, `<\App\Card>` (namespace-qualified) | a **component** - a namespace-qualified or fully-qualified class name |
+| `<Author::byline>` | a **component** - a public static method on a class |
+| `<$tag>`, `<{expr}>` (a variable / any expression) | a **dynamic tag** - the runtime string value is classified by the same rule, at runtime |
+
+Any tag whose name is capitalized, contains a namespace separator (`\`), or names a static method (`::`) is a component; everything else is a literal HTML element.
+
+A **component produces `Html\Htmlable`**, and every component tag resolves through the *class* name rules alone. There are two forms:
+
+```php
+// Class implementing Html\Htmlable - the instance IS the renderable
+class Card implements Html\Htmlable {
+    public function __construct(public string $title) {}
+    public function toHtml(): Html\Htmlable {
+        return <div class="card">{$this->title}</div>;
+    }
+}
+// <Card title="Hi" />  →  new Card(title: 'Hi')
+
+// Static method - multiple small components can live together on one class
+class Author {
+    public static function byline(string $name): Html\Htmlable { /* ... */ }
+    public static function avatar(string $src): Html\Htmlable { /* ... */ }
+}
+// <Author::byline name="Rasmus" />  →  Author::byline(name: 'Rasmus')
+```
+
+`toHtml()` returns markup, not a string, so it composes under `strict_types` with no cast, and callers can still reach the produced `Html\Element` tree. It may also return another `Htmlable` - e.g. delegate to another component instance. A static-method component must likewise return `Html\Htmlable`, and must be public, static, and user-defined.
+
+Both forms resolve through the class resolution every PHP developer already knows - a `<Author::byline/>` tag's *class part* resolves exactly as `Author::class` would. Plain *function* components are deferred to Future Scope: a bare `<Foo/>` gives no syntactic signal whether a class or a function is meant, and PHP resolves the two through separate `use` / `use function` import tables, so supporting functions means dual-candidate name resolution in the compiler and a class-vs-function dispatch order at runtime (plus guarding tags like `<Date/>` from resolving to internal functions such as `date()`). A static method has no such ambiguity.
+
+#### Bare-tag and qualified-tag resolution
+
+A component tag resolves exactly as a class name does - honoring `use` imports and the current namespace, precisely as `Foo::class` would where the tag appears. The same applies to the class part of a static-method tag:
+
+```php
+namespace Views;
+
+use App\Card;
+use App\Author;
+
+<Card title="Hi" />         // → new App\Card(title: 'Hi')
+<Author::byline name="R"/>  // → App\Author::byline(name: 'R')
+```
+
+Tags may also be written **namespace-qualified** or **fully-qualified** directly; any tag containing `\` is a component regardless of the first letter's case:
+
+```php
+<App\Card title="Hi"/>    // namespace-relative
+<\App\Card title="Hi"/>   // fully-qualified
+```
+
+#### Dynamic tags - `<$tag>` and `<{expr}>`
+
+The tag position also accepts a dynamic value, for the common CMS/builder case where the element or component is data ("render this list of blocks"). It follows the rule PHP developers already know from double-quoted string interpolation: a simple variable may appear bare, and braces admit any expression:
+
+```php
+$tag = $isImportant ? 'strong' : 'span';
+echo <$tag class="note">{$text}</$tag>;
+
+echo <{$block->type} {...$block->attributes} />;
+echo <{$isImportant ? 'strong' : 'span'}>{$text}</>;
+```
+
+This is consistent with the rest of the grammar, where braces already mark every dynamic value.
+
+The value is classified **at runtime by exactly the compile-time rule**: a string with an uppercase first character, a `\`, or a `::` dispatches as a component; anything else constructs a literal `Html\Element`. So `$tag = 'div'` behaves like `<div>` and `$component = Card::class` behaves like `<Card/>`, and only classification moves to runtime. Two differences follow from the name being data rather than source: it is not resolved against `use` imports (there is no compile-time name to resolve - pass a fully-qualified name, which `::class` already produces), and element names are validated when the tree is serialized rather than when it is parsed (the existing `Html\Element` rule; an invalid name throws, it can never break out of the markup).
+
+Closing follows the form:
+- A variable tag closes by repeating the same variable such as `<$a>...</$a>`
+    - `<$a>...</$b>` is a compile error, exactly as `<div>...</span>` is
+- An expression tag with a brace closes **anonymously** with `</>`
+    - A closing tag cannot restate the expression - re-evaluating it would run its side effects twice, and matching it textually is meaningless for a computed value; the expression is evaluated exactly once.
+- A self-closing `<$tag/>` / `<{expr}/>` needs no closer at all.
+
+#### Userland integration: dispatch hooks
+
+By default the engine constructs a class component with `new` and calls a static-method component directly. In userland, particularly within frameworks, they will often want to intervene - to resolve components through a dependency-injection container (autowiring the constructor dependencies the props do not supply), or to apply a cross-cutting transform to every component's output. Two request-scoped hook lists make this possible without touching any component's code. Each behaves like `spl_autoload_register` - handlers are kept in registration order, with a matching `unregister_*` that reports whether a handler matched:
+
+| Hook | Fires for | Signature | Purpose |
+|---|---|---|---|
+| `Html\register_component_factory` | class components | `(string $class, array $args): ?object` | replace `new` (e.g. container construction) |
+| `Html\register_component_decorator` | **every** component kind | `(Html\Htmlable $rendered, string $component): Html\Htmlable` | transform / wrap / log / cache the output |
+
+The engine always does the part only it can: resolve the name, confirm the target, and route props + `#[Html\Slot]` content into `$args`. A **factory** only changes *how a class component's instance is produced* - it returns an instance of the requested class, or `null` to defer to the next handler (and finally to the engine's own `new`). A **decorator** is the cross-cutting seam: it runs on the `Html\Htmlable` every component produces - class and static-method alike - composing in registration order. (Plain HTML elements such as `<div>` are not components; no hook fires for them. A static-method component's *call* has no production hook; a component that needs container construction is a class component.)
+
+Every `register_*`/`unregister_*` function also takes an optional second argument, `?string $component = null`, that scopes the hook to a single component: the hook only fires when the resolved name it would receive - the class FQCN, or `"Class::method"` - matches (case-insensitively, with or without a leading backslash). Scoped and unscoped hooks share one chain in registration order, and the dispatch skips out-of-scope hooks inside the engine, before any userland call, so a hook registered for one component costs the others nothing. Unregistering matches on both the callable and the scope it was registered with.
+
+Registration is scoped to the current runtime, so a framework registers hooks during bootstrap; when nothing is registered the hooks add no cost - the default `new`/call path is unchanged.
+
+```php
+$container = ...;
+
+// A framework's bootstrap: wire components to the service container...
+Html\register_component_factory(
+    fn(string $class, array $args) => $container->make($class, $args)
+);
+
+// ...and a cross-cutting decorator (profiling, caching, wrapping, ...).
+Html\register_component_decorator(function (Html\Htmlable $rendered, string $component) {
+    return $rendered;
+});
+```
+
+A component can then simply declare its dependencies; the container supplies them while markup attributes still fill the remaining parameters as named arguments:
+
+```php
+final class UserCard implements Html\Htmlable {
+    public function __construct(private Clock $clock, public string $name) {}
+    public function toHtml(): Html\Htmlable { /* ...uses $this->clock... */ }
+}
+
+<UserCard name="Rasmus"/>   // the container injects $clock; the prop fills $name
+```
+
+### 4. Attributes
+
+```php
+<a href={$url} class="btn" data-id={$id} disabled {...$extra}>{$label}</a>
+```
+
+| Form | Meaning |
+|---|---|
+| `class="btn"` | literal string |
+| `href={$expr}` | PHP expression (same `{}` as interpolation) |
+| `disabled` (bare) | boolean `true` |
+| `{...$attrs}` | spread (array → attributes; named-argument unpacking for components) |
+
+* Attribute names are **native HTML names** (`class`, `for`, `data-x`) - *not* `className`. PHP accepts reserved words as parameter names and named-argument labels, so no `className`/`htmlFor` aliasing is needed like JSX.
+* On **HTML elements**, attributes become a string-keyed map.
+* On **components**, attributes become **named arguments**. Unknown attributes are a `TypeError` (`Unknown named parameter`) unless the component declares a `...$attrs` variadic, which collects them as a string-keyed array - exactly PHP's existing named-argument + variadic semantics, no new machinery. Hyphenated names (`data-x`, `aria-y`) are not legal named-argument *labels* in a normal call, but as markup attributes they pass through the same mechanism and are collected by the variadic.
+
+#### Attribute value coercion
+
+| Value | Result |
+|---|---|
+| `null` / `false` | attribute **omitted** |
+| `true` | boolean attribute (bare name) |
+| `string` / `int` / `float` / `Stringable` | `="escaped value"` |
+| `array` / other | `TypeError` |
+
+### 5. Children and slots
+
+#### HTML elements
+
+Children are an ordered list of child nodes (text, interpolations, sub-elements).
+
+#### Components - the body slot via `#[Html\Slot]`
+
+The body of a component is routed to the constructor parameter marked with the `#[Html\Slot]` attribute.
+
+```php
+class Time implements Html\Htmlable {
+    public function __construct(
+        public DateTimeInterface $datetime,
+        #[Html\Slot] public ?Html\Htmlable $slot = null,
+    ) {}
+    public function toHtml(): Html\Htmlable {
+        return <time datetime={$this->datetime->format('c')}>
+            {$this->slot ?? Html\escape($this->datetime->format('F j'))}
+        </time>;
+    }
+}
+
+// <Time datetime={$d} />            →  new Time(datetime: $d)
+// <Time datetime={$d}>July 4</Time> →  new Time(datetime: $d, slot: <fragment "July 4">)
+```
+
+The slot value is always a single `Html\Fragment` (an `Html\Htmlable` whose children are each normalized to `Html\Htmlable`); `{$slot}` renders the whole body, correctly escaped. The fragment's children are introspectable as an opt-in (`$slot->children`).
+
+Rules for the slot parameter:
+
+* **At most one** parameter may carry `#[Html\Slot]`; more than one is an **error**.
+* Body content given to a component with no `#[Html\Slot]` parameter, or a parameter filled both by an attribute and by body content, is an **error**.
+* `#[Html\Slot]` on a variadic parameter → **error** (a slot is a single value).
+* The slot is an ordinary parameter, so a **required** slot (no default) left unfilled fails at runtime like any missing argument (`ArgumentCountError`). Declare a default (`?Html\Htmlable $slot = null`) to make it optional.
+
+#### Further content areas are markup-valued props
+
+A component has exactly one body slot; any *additional* content regions are passed as ordinary props typed `Html\Htmlable`. Because an attribute value is an arbitrary expression and markup is a value, a chunk of markup passes straight through with no extra syntax:
+
+```php
+class Layout implements Html\Htmlable {
+    public function __construct(
+        #[Html\Slot] public Html\Htmlable $body,
+        public ?Html\Htmlable $header = null,
+        public ?Html\Htmlable $footer = null,
+    ) {}
+    public function toHtml(): Html\Htmlable { /* ... */ }
+}
+
+<Layout
+    header={<h1>Title</h1>}
+    footer={<>© 2026</>}
+>
+    <p>Body content flows to the slot.</p>
+</Layout>
+```
+
+A "named slot" is therefore just a prop, checked against the component's real signature exactly like any other - a misspelled `heaer=` is the same `TypeError` a misspelled prop is, not a silent no-op. This keeps the whole surface consistent with the RFC's headline property that props are type-checkable named arguments.
+
+This is also the proposal's answer to **template inheritance**: what Twig, Latte and Blade's older syntax call a base template with overridable *blocks* is here a `Layout` component whose regions are markup-valued props (and the body slot) filled by composition, rather than a template that is extended; layouts nest the same way. (A dedicated `<slot:name>` block form for large named regions is a possible future ergonomic addition - see Future Scope - but expresses nothing a prop cannot.)
+
+#### Eager evaluation, and opting into laziness with `:lazy`
+
+Because a component invocation is an ordinary call, **the body is fully evaluated before the component runs** (PHP evaluates arguments before the call). A component therefore cannot, by default, conditionally skip or defer rendering its body - the body has already been built by the time the component decides what to do with it.
+
+The `:lazy` directive on a component tag opts its body out of that rule:
+
+```php
+class Auth implements Html\Htmlable
+{
+    public function __construct(
+        public bool $check,
+        #[Html\Slot] public ?Html\Htmlable $slot = null,
+    ) {}
+    public function toHtml(): Html\Htmlable
+    {
+        // When logged out we never reference $slot, so with :lazy the body's
+        // expressions never run.
+        return $this->check ? <div class="user">{$this->slot}</div> : <></>;
+    }
+}
+
+// Eager: auth()->user()->name is evaluated before Auth runs - and would error
+// when logged out - even though Auth discards the body in that case.
+<Auth check={auth()->check()}>Hello, {auth()->user()->name}</Auth>
+
+// Lazy: the body is built, and its interpolations run, only if Auth renders it.
+<Auth :lazy check={auth()->check()}>Hello, {auth()->user()->name}</Auth>
+```
+
+With `:lazy` the body lowers to an `Html\LazyFragment` wrapping a closure, instead of an eager `Html\Fragment`:
+
+```php
+// <Auth :lazy>Hello, {$name}</Auth>
+// → \Html\render_component(Auth::class, [],
+//       new \Html\LazyFragment(fn() => new \Html\Fragment(['Hello, ', $name])), 'Auth')
+```
+
+`Html\LazyFragment` is *itself* an `Html\Htmlable`, so **the component's slot parameter type is unchanged** (`?Html\Htmlable`) and a component need not be written any differently to accept a lazy body - laziness is transparent to it. It evaluates its closure on first render and **memoizes** the result, so a body rendered more than once still runs its expressions once. Variables the body references are captured by value at the point of the tag (ordinary arrow-function semantics); only the *expressions* - method calls, property reads - are deferred to render time. A body that is never rendered is never evaluated.
+
+`:lazy` is deliberately the single point where markup departs from "an ordinary call with eager arguments," which is why it is explicit and opt-in; eager remains the default. (For a body that should be evaluated *repeatedly* rather than merely deferred, pass a closure as an ordinary prop and call it - e.g. `each={fn($x) => <li>{$x}</li>}`.)
+
+#### Child coercion
+
+| Child value | Renders as |
+|---|---|
+| `Html\Htmlable` | itself, **not** escaped (resolved through `toHtml()` and serialized natively) |
+| `string` / `int` / `float` / `bool` / `null` | cast to string and escaped - so `false`/`null` → `""`, `true` → `"1"` |
+| `array` / `Traversable` | flattened, each element coerced recursively |
+| non-`Stringable` object / resource | `TypeError` |
+
+This makes control flow ride entirely on `{...}` with no new directives, exactly what JSX has landed on:
+
+```php
+<ul>{array_map(fn($i) => <li>{$i->name}</li>, $items)}</ul>      // loop (array flattens)
+<div>{$user !== null ? <span>{$user->name}</span> : null}</div>  // conditional (null → "")
+<div>{$loggedIn ? <a href="/logout">Log out</a> : null}</div>    // optional (null → "")
+```
+
+Conditionals use a ternary, not the JSX `{condition && <x/>}` idiom: in PHP, `&&` evaluates to a boolean, so `{$cond && <x/>}` would render `"1"`, not the element.
+
+### 6. Syntax structure
+
+* **Closing tags must match** their opener, including `</Author::byline>` and the dynamic `</$tag>`. Mismatches are a compile error (catches the most common markup typo early).
+* **Childless elements**: `<div></div>` and `<div/>` are equivalent - existing HTML can be pasted into markup unchanged. The parser needs **no hardcoded HTML void-element list**; the serializer still *emits* `<br>` (no closing tag, no slash) for known void elements, so output is clean HTML5 whichever source form was used. Giving a void element children (possible when constructing `Html\Element` by hand) is an error rather than silent data loss.
+* **Fragments** `<>...</>` produce an `Html\Fragment` with no wrapper element.
+* **Whitespace** follows the JSX/Babel algorithm: split each text run into lines, trim leading whitespace on every line but the first and trailing whitespace on every line but the last, drop blank lines, and join the surviving lines with a single space. The net effect is that indentation/newlines between block elements vanish while a meaningful single space between inline content is preserved.
+* **Character references**: markup text and literal attribute values decode HTML character references at compile time - the full WHATWG named set (semicolon-terminated forms only) plus numeric `&#8212;` / `&#x2014;`. The named list is *frozen by the HTML standard*, so it is baked into the scanner as a generated table. Decoding is lenient like HTML and JSX: a bare `&`, an unknown name, or an invalid numeric form stays literal - `<p>fish & chips</p>` needs no escaping. The decoded value is an ordinary string escaped at render time, so `&amp;` round-trips and `&lt;script&gt;` can never smuggle real markup structure. Text decodes *after* whitespace normalization; comment contents and interpolated PHP strings are never decoded, and `token_get_all()` still sees the raw source.
+* **Literal braces**: `{` begins interpolation, so a literal `{` in text is written as in HTML or JSX - a character reference (`&#123;` / `&lbrace;`) or an interpolated string (`{'{'}`). A lone `}` is already literal. No additional escape syntax (eg. Blade-style `@{{`) is introduced. A block of literal JSON/JS inside `<script>` wants the `Html\raw()` JSON-island pattern from Escape-by-default instead.
+* **Comments**: `<!-- ... -->` is emitted as a literal HTML comment; `{/* ... */}` renders   nothing (source-only).
+* **Doctype**: `<!DOCTYPE html>` is allowed in *content position* and emitted verbatim (case-insensitive, no interpolation). It does **not** begin a markup expression - a markup expression is a single root node, so a full document wraps it in a fragment, exactly as JSX handles sibling roots: `<> <!DOCTYPE html> <html>...</html> </>`. Position is not validated (browsers ignore a misplaced doctype; it is the author's responsibility). Other `<!` declarations (e.g. CDATA sections, which terminate at `]]>` and may contain `>`) are a parse error with a targeted message.
+
+### 7. Element model
+
+Markup builds a **lightweight, immutable value-object tree** (`Html\Element`,`Html\Fragment`), *not* PHP 8.4's `Dom\*` tree. Reasons:
+
+1. **Document ownership** - a `Dom\Element` must be created from and owned by a `Dom\Document`; markup literals are free-floating values, which fights that model.
+2. **Cost** - DOM nodes are heavyweight (parent pointers, owner document, namespaces, live collections); templating wants cheap throwaway nodes per value.
+3. **`Html\raw()`** requires opaque byte passthrough to avoid confusion to end users, which a DOM cannot represent without parsing and reserializing (potentially altering it).
+4. **Component contract** - returning `Html\Htmlable` (one method) is far lighter than returning a document-owned `Dom\Node`.
+
+The two worlds can still connect through the string boundary, in userland, with no dedicated API: markup renders to HTML (`Dom\HTMLDocument::createFromString((string) $el)` or a fragment parse via `innerHTML`), and a DOM node serializes to HTML that `Html\raw()` accepts as a child.
+
+### 8. New symbols
+
+The runtime lives in a new always-enabled bundled extension, `ext/html`. It cannot be disabled (like `ext/random`): the syntax lowers into these symbols at compile time, so a build without them would parse markup and then fail at runtime.
+
+All under the `Html\` namespace:
+
+* Interface `Html\Htmlable extends Stringable` - the renderable contract. The one method a class writes is `toHtml(): Htmlable`, which returns markup (ultimately an `Element`/`Fragment`/`Raw`). The inherited `__toString(): string` requirement is satisfied automatically: a userland class that does not declare (or inherit) a `__toString` of its own receives a default implementation at class-link time - it serializes what `toHtml()` produces - exactly the way every enum receives `cases()`. So `echo`/`(string)` work on any markup value or component, while `strict_types` components can `return <div>...</div>;` directly and callers can still reach the object tree via `toHtml()`. A declared `__toString` wins for string casts; markup rendering always goes through `toHtml()`.
+* Classes `Html\Element`, `Html\Fragment` (and `Html\Raw`, the opaque passthrough that backs `raw()`/`escape()`). All are `final`, immutable value objects with `readonly` properties (`$tag`, `$attributes`, `$children` / `$html`).
+* Class `Html\LazyFragment` - a `final` `Html\Htmlable` wrapping a `Closure` thunk (`__construct(Closure $thunk)`). The `:lazy` directive lowers a component body into one; it evaluates the thunk on first render and memoizes the result (see Children & slots). Not typically written by hand.
+* Attribute `Html\Slot` (bare `#[Html\Slot]`, no arguments) marking the parameter that receives a component's body.
+* Functions `Html\raw(string $html): Html\Htmlable`, `Html\escape(string $text): Html\Htmlable`.
+* Function `Html\render_component()` - the runtime target a component tag lowers into (resolved class name, props, slot). It is a public function so the dispatch rules are testable and so generated code is honest, but user code is expected to write tags, not call it.
+* Function `Html\render_dynamic()` - the runtime target a dynamic tag `<$tag>` lowers into: classifies the value by the element-vs-component rule and either constructs an `Html\Element` or dispatches through the `render_component()` machinery. Public for the same reasons.
+* Dispatch hooks, each with a matching `unregister_*` returning `bool`: `Html\register_component_factory()`, `Html\register_component_decorator()`. Each takes an optional `?string $component = null` scoping the hook to one component. Registering a non-callable throws a `TypeError` immediately (as `spl_autoload_register()` does).
+
+### Error handling
+
+Compile-time violations (mismatched closing tag, a stray `<` in markup text) throw the standard **`CompileError`** / **`ParseError`**, catchable exactly like any other PHP syntax error. At runtime, unsupported attribute/child value types throw **`TypeError`**; invalid dynamically-supplied tag/attribute names throw **`ValueError`**; dispatch failures (unknown component, non-`Htmlable` return, a misconfigured slot) throw **`Error`**.
+
+## Examples
+
+The constructs above compose with no special cases. The examples below show how they combine in the scenarios everyday template code actually consists of.
+
+### A page is one expression
+
+A markup expression spans as many lines as it needs. It is an ordinary expression, so the statement simply ends at the `;` - there is no heredoc-style terminator and no directive to close - and PHP control flow stays available inside `{}` throughout:
+
+```php
+function ProductPage(Product $product, User $viewer): Html\Htmlable
+{
+    return <Layout title={$product->name} header={<>
+            <h1>{$product->name}</h1>
+            {$product->onSale ? <span class="badge">Sale</span> : null}
+        </>}>
+        <p class="description">{$product->description}</p>
+        <ul class="features">
+            {array_map(fn($feature) => <li>{$feature}</li>, $product->features)}
+        </ul>
+
+        {$viewer->isAdmin() ? <a href={"/admin/products/{$product->id}"}>Edit</a> : null}
+    </Layout>;
+}
+```
+
+### Typed props - enums and `match`
+
+Attribute expressions are arbitrary PHP, and component props are real, typed parameters - so a prop can be an enum, and its value can be computed inline with `match`:
+
+```php
+enum Variant: string
+{
+    case Primary = 'btn-primary';
+    case Secondary = 'btn-secondary';
+}
+
+class Button implements Html\Htmlable
+{
+    public function __construct(
+        public Variant $variant,
+        #[Html\Slot] public Html\Htmlable $label,
+    ) {}
+    public function toHtml(): Html\Htmlable
+    {
+        return <button class={$this->variant->value}>{$this->label}</button>;
+    }
+}
+
+echo <Button variant={match ($theme) {
+    'brand' => Variant::Primary,
+    default => Variant::Secondary,
+}}>Click me</Button>;
+
+// <button class="btn-secondary">Click me</button>
+```
+
+A prop mismatch - a misspelled attribute name, a string where the enum is expected - is an ordinary `TypeError`, and because the signature is real, static analysers can report it before the code ever runs.
+
+### JSON output in markup
+
+As the `{` character in markup triggers PHP syntax, it is important to note the character can still be output in various ways - it is the same workaround JSX requires:
+
+```php
+echo <script type="application/ld+json">{Html\raw(json_encode($json))}</script>;
+
+echo <script type="application/ld+json">{Html\raw('
+    {
+        "@type": "WebPage",
+        "name": "PHP",
+        "url": "https://php.net",
+        "@context": "http://schema.org"
+    }
+')}</script>;
+
+echo <div>{'{'}example{'}'}</div>;
+```
+
+### Components are testable values
+
+A component is an ordinary object and its `toHtml()` result an ordinary value object, so a component is unit-tested directly: construct it, assert against the tree - no rendering, no string matching, no DOM parsing:
+
+```php
+public function testSaleBadgeShownWhenOnSale(): void
+{
+    $el = (new ProductBadge(product: $this->saleProduct()))->toHtml();
+
+    $this->assertInstanceOf(Html\Element::class, $el);
+    $this->assertSame('span', $el->tag);
+    $this->assertSame('badge sale', $el->attributes['class']);
+}
+```
+
+Views decompose the way any other code does: small component classes, each testable in isolation, composed by a top-level component returning the final page.
+
+### Framework components - a Livewire-style clock
+
+In frameworks whose components are PHP classes that render themselves - Livewire is the clearest example - the class and its markup are forced apart today: the component holds the state and behaviour, while the HTML lives in a separate Blade file the class points to by name.
+
+With markup expressions the same component could collapse into one self-contained class - `render()` returns the view instead of naming a file that contains it:
+
+```php
+class Clock extends Component
+{
+    public string $timezone = 'UTC';
+
+    public function render(): Html\Htmlable
+    {
+        return <div wire:poll.1s>
+            <span class="time">{now($this->timezone)->format('H:i:s')}</span>
+        </div>;
+    }
+}
+```
+
+## Backward Incompatible Changes
+
+`<` is heavily overloaded in PHP (`<`, `<=`, `<=>`, `<<`, `<>`, `<<<`), so this was the main design risk. It is resolved by the same technique JavaScript uses to tell regex from division: the scanner tracks whether it is in **operand position** (a value is expected) or **operator position** (a value just ended), from the last significant token. Markup begins only when `<` is in operand position *and* is immediately followed by `[A-Za-z>]`, by `\` then a letter (a fully-qualified component tag such as `<\App\Card/>`), by `$` then a variable name, or by `{` (the dynamic tags `<$tag>` / `<{expr}>`):
+
+* In `$a < $b` (or the no-space `$a <$b`), `<` follows an operand → comparison, unchanged.
+* In `$a < \Foo::BAR`, `<` is in operator position → comparison, unchanged.
+* In `return <div>`, `<` is in operand position followed by a letter → markup.
+
+The operand-position decision is an explicit allowlist that **fails closed**: markup begins only after a token that *expects* an operand - `return`, `echo`, `=`, `(`, `,`, `=>`, binary and assignment operators, casts, and the other expression-introducing contexts - which are exactly the positions where an infix `<` cannot legally appear today, and where `<` followed by a letter, `$`, `{`, or `>` is *always a syntax error*. After every other token, `<` keeps its existing meaning. Two properties follow:
+
+* **No valid program changes meaning, by construction.** Reclaiming `<` only ever applies where the source could not previously compile.
+* **The design is future-proof in the safe direction.** If a token is missing from the allowlist (or a future PHP version adds a new operator and forgets to include it), the only consequence is that markup cannot directly follow that token - a loud, feature-side parse error worked around with parentheses and fixed by a one-line addition. A gap can never silently change what existing code means.
+
+`<>` is the legacy alias of `!=` and is preserved in infix position (`$a <> $b` is still not-equal). `<>` is only reinterpreted as a fragment opener in **operand position**, where it is currently a syntax error - so no valid program needs changes. Two positions are deliberately excluded from the allowlist because an infix `<` after them is (or may be) valid PHP: after a bare `yield` (`yield < LIM` is valid, so yielding markup is written `yield (<div/>)`) and after a closing `}` (which ends `match` and interpolation values), so markup as a bare expression statement immediately following a block is assigned or echoed instead.
+
+This leaves just one backwards compatibility concern:
+
+1. **New `Html\` namespace** - introduces `Html\Htmlable`, `Html\Element`, `Html\Fragment`, `Html\Raw`, `Html\Slot`, `Html\raw()`, `Html\escape()`. Top-level `Html\` follows the established precedent for bundled extensions (`Random\`, `Dom\`, `Uri\`), and real-world top-level `Html\` packages are rare. No existing keywords are reserved and no new global reserved words are introduced (the syntax uses bare `<`, and the `:lazy` directive is only meaningful inside a markup tag).
+
+### Impact on tooling
+
+The scanner emits new `T_MARKUP_*` tokens (exposed as constants and through `token_get_all()`/`PhpToken`); ordinary code continues to tokenize identically. Tools that parse PHP source (nikic/php-parser, PHPStan, Psalm, php-cs-fixer, IDEs) will need grammar updates to understand markup expressions, as with any new syntax.
+
+A working syntax-highlighting/IDE extension for VS Code was built alongside the reference implementation to validate that the syntax is toolable.
+
+Because markup lowers to ordinary AST at compile time, everything downstream of the parser is unaffected: opcache caches and restores markup-containing files normally (verified, including the file cache), and reflection, serialization, `var_export()`, `clone` and `json_encode()` on the value objects behave as for any other class.
+
+A related question is what this means for **template engines** (Blade, Twig, Latte). This RFC does not replace them, and does not aim to: a full engine is much more than syntax plus escaping - layout inheritance, a designer-facing dialect that is deliberately *not* PHP, sandboxed rendering of untrusted templates, context-aware escaping, fragment caching, and years of ecosystem conventions. Nothing here removes any of that; markup is opt-in syntax, and code that never uses it is untouched.
+
+What this RFC offers the engines is a first-class substrate to build on. Today each engine maintains its own parser, its own escaping, and its own component model, because the language provides none. With markup native, an engine can adopt the shared foundation where it fits: `Html\Htmlable` is a common currency (a Blade view and a markup expression can accept and return the same interface and compose within one page); the dispatch hooks exist precisely so a framework can route component tags through its existing container and resolution logic; and an engine's component layer could compile *to* markup expressions, inheriting escape-by-default and end-to-end static analysis for free. The likely long-term shape is convergence rather than replacement: engines keep their higher-level features and progressively delegate parsing, escaping, and the value model to the language - much as database layers did not disappear when PDO shipped, but re-based onto it.
+
+## Future Scope
+
+Some natural extensions are deliberately left out of this RFC to keep its scope tight and expandable in the future; none is required for the feature to be useful:
+
+* **Context-aware escaping** (URL/JS/CSS contexts), as in Go's `html/template` or Latte's escaping, - so that e.g. a `javascript:` URL in `href` is caught. This RFC escapes HTML context only; the value-tree model is designed so this can be layered on later without a syntax change. Some examples include:
+  * A JavaScript escaping context inside `<script>` tags, `onload=""`, `onclick=""`, etc. attributes
+  * A CSS escaping context inside `<style>` tags or `style=""` attributes
+* **Function components** - plain functions (`<Greeting/>` → `greeting()`) as component tags. Deferred because a bare tag gives no syntactic signal whether a class or a function is meant, and PHP resolves the two through separate `use` / `use function` import tables - supporting functions needs dual-candidate name resolution in the compiler (a function-name analogue of `Foo::class`), a class-then-function dispatch order at runtime, a guard against tags resolving to internal functions (`<Date/>` → `date()`), and an *invoker* hook alongside the factory so containers can autowire calls as well as construction. All of it is purely additive - no syntax change - and the reference implementation had a complete working version, so this is a natural first follow-up RFC. In v1 a small function component is a small class or a static method instead.
+* **A dedicated `<slot:name>` block form** for passing large named regions, as an ergonomic alternative to markup-valued props for content that reads better as a block than as an attribute value. It would be pure sugar over what props already express (see Children & slots), so it is deferred rather than shipped in v1.
+* **Further laziness controls** - the `:lazy` directive already defers a component's body (see Children & slots); a natural extension is deferring individual markup-valued props the same way, or a component declaring that its body is always lazy so callers need not write `:lazy`.
+* **DOM interoperability APIs** - a built-in `toDom(?Dom\Document): Dom\DocumentFragment` on the node classes, and accepting a `Dom\Node` directly as a markup child. Both are expressible in userland today through the string boundary (see Element model), so they are deferred; a native version would also want ext/dom to expose `HTMLTemplateElement::$content` first, so fragments can parse in `<template>` context instead of "in body" context (which mangles top-level `<td>`/`<tr>`).
+* **XML support** more in line with XHP's original design.
+* **Control structures** in the markup syntax, such as Vue's `v-if`.
+* **Dedicated template files**, potentially reigniting the `.phpc` file debate.
+
+## Reference implementation status
+
+* **Zero regressions** across the `Zend/tests`, `tests/`, `ext/tokenizer` and `ext/dom` suites (6000+ tests); 50+ dedicated `ext/html` tests (including bare/qualified/fully-qualified resolution and the dispatch hooks).
+* **opcache-safe** - markup compiles to ordinary opcode literals that persist and restore through the file cache (verified).
+* **Safe by construction** - dynamically-supplied tag/attribute names are validated so a spread key or `new Element($x)` can never break out of the markup; child recursion is depth-bounded.
+* **No measurable cost to non-markup code** - the syntax itself is zero-cost versus the equivalent hand-written `Html\Element` objects (it compiles to exactly those), and the scanner change is within measurement noise on ordinary PHP.
+
+## References
+
+* JSX specification - https://facebook.github.io/jsx/
+* Laravel Blade, Twig, Latte - escape-by-default precedent in PHP templating.
+
+### History and related work
+
+* XHP - https://en.wikipedia.org/wiki/XHP ; Hack/HHVM docs: https://docs.hhvm.com/hack/XHP/introduction/
+* Facebook's original PHP 5 extension (archived): https://github.com/facebookarchive/xhp-php5-extension
+* `phplang/xhp` - XHP for PHP 7+ as a community extension: https://github.com/phplang/xhp
+* Internals discussion endorsing the XHP approach over an auto-escape flag (2018):  https://externals.io/message/91797
+* Adjacent string-interpolation RFCs: https://wiki.php.net/rfc/arbitrary_string_interpolation , https://wiki.php.net/rfc/arbitrary_expression_interpolation
+* Userland JSX-for-PHP experiment - https://github.com/attitude/phpx
\ No newline at end of file
diff --git a/ext/html/config.m4 b/ext/html/config.m4
new file mode 100644
index 000000000000..87674e42d966
--- /dev/null
+++ b/ext/html/config.m4
@@ -0,0 +1,7 @@
+dnl Always enabled and never shared: the native markup syntax in the Zend
+dnl scanner/parser is unconditional and lowers into the Html\ symbols this
+dnl extension registers, so a build without it would accept the syntax and then
+dnl fail at runtime (compare ext/random). See config.w32 for the Windows side.
+PHP_NEW_EXTENSION([html], [html.c], [no])
+PHP_INSTALL_HEADERS([ext/html], [php_html.h])
+PHP_ADD_EXTENSION_DEP(html, standard)
diff --git a/ext/html/config.w32 b/ext/html/config.w32
new file mode 100644
index 000000000000..1f7060de0dc5
--- /dev/null
+++ b/ext/html/config.w32
@@ -0,0 +1,8 @@
+// vim:ft=javascript
+
+// Always enabled: the native markup syntax lowers into the Html\ symbols this
+// extension registers, so it cannot be disabled (compare ext/random).
+EXTENSION("html", "html.c", false /* never shared */);
+PHP_HTML = "yes";
+PHP_INSTALL_HEADERS("ext/html", "php_html.h");
+ADD_EXTENSION_DEP("html", "standard");
diff --git a/ext/html/html.c b/ext/html/html.c
new file mode 100644
index 000000000000..3599142f14d0
--- /dev/null
+++ b/ext/html/html.c
@@ -0,0 +1,1673 @@
+/*
+   +----------------------------------------------------------------------+
+   | Copyright © The PHP Group and Contributors.                          |
+   +----------------------------------------------------------------------+
+   | This source file is subject to the Modified BSD License that is      |
+   | bundled with this package in the file LICENSE, and is available      |
+   | through the world-wide-web at the following url:                     |
+   | https://www.php.net/license/3_01.txt                                 |
+   | If you did not receive a copy of the PHP license and are unable to   |
+   | obtain it through the world-wide-web, please send a note to          |
+   | license@php.net so we can mail you a copy immediately.               |
+   +----------------------------------------------------------------------+
+   | Author: Liam Hammett                                                 |
+   +----------------------------------------------------------------------+
+*/
+
+/* Native Markup Expressions.
+ *
+ * This extension provides the `Html\` value-object tree that markup expressions
+ * lower into: Element, Fragment, Raw, the Htmlable interface, the Slot
+ * attribute, and the raw()/escape() helpers. It owns escaping and serialization
+ * so the escape-by-default safety guarantee lives in core, not userland.
+ *
+ * No parser/scanner changes live here; the markup syntax that lowers into these
+ * symbols lives in Zend/zend_language_scanner.l, Zend/zend_language_parser.y,
+ * and Zend/zend_markup.c (see Zend/zend_markup.h for the shared vocabulary). */
+
+#ifdef HAVE_CONFIG_H
+# include "config.h"
+#endif
+
+#include "php.h"
+#include "php_html.h"
+
+#include "Zend/zend_attributes.h"
+#include "Zend/zend_closures.h"
+#include "Zend/zend_markup.h"
+#include "Zend/zend_extensions.h"
+#include "Zend/zend_interfaces.h"
+#include "Zend/zend_iterators.h"
+#include "Zend/zend_observer.h"
+#include "Zend/zend_smart_str.h"
+#include "Zend/zend_exceptions.h"
+#include "Zend/zend_language_scanner.h"
+#include "ext/standard/html.h"
+#include "ext/standard/info.h"
+
+#include "html_arginfo.h"
+
+ZEND_DECLARE_MODULE_GLOBALS(html)
+
+zend_class_entry *html_ce_Htmlable;
+zend_class_entry *html_ce_Element;
+zend_class_entry *html_ce_Fragment;
+zend_class_entry *html_ce_Raw;
+zend_class_entry *html_ce_Slot;
+zend_class_entry *html_ce_LazyFragment;
+
+/* Html\LazyFragment carries internal state a plain property bag cannot: a
+ * Closure thunk plus a memoized result that is written on first render. A
+ * custom object holds both out of userland view; the class exposes no
+ * properties. */
+typedef struct {
+	zval thunk;     /* the Closure building the deferred body */
+	zval resolved;  /* memoized Html\Htmlable, IS_UNDEF until first render */
+	zend_object std;
+} html_lazy_fragment;
+
+static zend_object_handlers html_lazy_fragment_handlers;
+
+static zend_always_inline html_lazy_fragment *html_lazy_fragment_from_obj(zend_object *obj)
+{
+	return (html_lazy_fragment *)((char *)obj - offsetof(html_lazy_fragment, std));
+}
+
+static zend_object *html_lazy_fragment_create(zend_class_entry *ce)
+{
+	html_lazy_fragment *lf = zend_object_alloc(sizeof(html_lazy_fragment), ce);
+	zend_object_std_init(&lf->std, ce);
+	object_properties_init(&lf->std, ce);
+	ZVAL_UNDEF(&lf->thunk);
+	ZVAL_UNDEF(&lf->resolved);
+	lf->std.handlers = &html_lazy_fragment_handlers;
+	return &lf->std;
+}
+
+static void html_lazy_fragment_free(zend_object *obj)
+{
+	html_lazy_fragment *lf = html_lazy_fragment_from_obj(obj);
+	zval_ptr_dtor(&lf->thunk);
+	zval_ptr_dtor(&lf->resolved);
+	zend_object_std_dtor(&lf->std);
+}
+
+static HashTable *html_lazy_fragment_get_gc(zend_object *obj, zval **table, int *n)
+{
+	html_lazy_fragment *lf = html_lazy_fragment_from_obj(obj);
+	zend_get_gc_buffer *buf = zend_get_gc_buffer_create();
+	zend_get_gc_buffer_add_zval(buf, &lf->thunk);
+	zend_get_gc_buffer_add_zval(buf, &lf->resolved);
+	zend_get_gc_buffer_use(buf, table, n);
+	return zend_std_get_properties(obj);
+}
+
+/* Method-table names of the default __toString() injected into userland
+ * Htmlable classes (see html_implement_htmlable). Permanent interned. */
+static zend_string *html_str_tostring;    /* "__toString" */
+static zend_string *html_str_tostring_lc; /* "__tostring" */
+
+/* arg_info for the injected default __toString(). The raw generated arginfo
+ * uses the registration-time zend_internal_arg_info layout; a function living
+ * in a class table must use the converted zend_arg_info layout (reflection and
+ * the VM assume it). Converted once at MINIT, exactly like zend_enum.c's
+ * zarginfo_* arrays for the injected cases()/from()/tryFrom(). */
+static zend_arg_info html_zarginfo_default_tostring[
+	sizeof(arginfo_class_Html_Htmlable___toString) / sizeof(zend_internal_arg_info)];
+
+static zend_string *html_render_htmlable(zval *value);
+
+/* htmlspecialchars($s, ENT_QUOTES | ENT_SUBSTITUTE | ENT_HTML401). The charset
+ * hint is NULL so the ini default_charset applies (UTF-8 by default), exactly as
+ * htmlspecialchars() does - a non-UTF-8 application keeps working. */
+static zend_string *html_escape_string(const char *s, size_t len)
+{
+	return php_escape_html_entities(
+		(const unsigned char *) s, len, /* all */ 0,
+		ENT_QUOTES | ENT_SUBSTITUTE | ENT_HTML401, NULL);
+}
+
+static void html_append_escaped(smart_str *buf, zend_string *str)
+{
+	zend_string *escaped = html_escape_string(ZSTR_VAL(str), ZSTR_LEN(str));
+	smart_str_append(buf, escaped);
+	zend_string_release(escaped);
+}
+
+/* A tag name must start with a letter and contain only name-safe characters, so a
+ * dynamically-supplied tag (`new Element($x)`) can never break out of the markup. */
+static bool html_is_valid_tag_name(zend_string *tag)
+{
+	if (ZSTR_LEN(tag) == 0) {
+		return false;
+	}
+	const char *p = ZSTR_VAL(tag);
+	if (!((p[0] >= 'a' && p[0] <= 'z') || (p[0] >= 'A' && p[0] <= 'Z'))) {
+		return false;
+	}
+	for (size_t i = 1; i < ZSTR_LEN(tag); i++) {
+		char c = p[i];
+		if (!((c >= 'a' && c <= 'z') || (c >= 'A' && c <= 'Z')
+				|| (c >= '0' && c <= '9') || c == '-' || c == '_' || c == '.' || c == ':')) {
+			return false;
+		}
+	}
+	return true;
+}
+
+/* An attribute name may not contain characters that would let a dynamically
+ * supplied key (spread, `new Element(...)`) break out of the attribute (HTML5
+ * attribute-name production). */
+static bool html_is_valid_attr_name(zend_string *name)
+{
+	if (ZSTR_LEN(name) == 0) {
+		return false;
+	}
+	for (size_t i = 0; i < ZSTR_LEN(name); i++) {
+		unsigned char c = (unsigned char) ZSTR_VAL(name)[i];
+		if (c < 0x20 || c == 0x7f || c == ' ' || c == '"' || c == '\''
+				|| c == '>' || c == '/' || c == '=' || c == '<') {
+			return false;
+		}
+	}
+	return true;
+}
+
+/* HTML5 void elements: serialized without a closing tag or trailing slash. */
+static bool html_is_void_element(zend_string *tag)
+{
+	static const char *const void_elements[] = {
+		"area", "base", "br", "col", "embed", "hr", "img", "input",
+		"link", "meta", "param", "source", "track", "wbr", NULL,
+	};
+
+	for (const char *const *v = void_elements; *v != NULL; v++) {
+		size_t len = strlen(*v);
+		if (ZSTR_LEN(tag) == len
+				&& zend_binary_strcasecmp(ZSTR_VAL(tag), len, *v, len) == 0) {
+			return true;
+		}
+	}
+	return false;
+}
+
+/* Bound the pure-C child recursion so a deeply nested array/Traversable cannot
+ * overflow the stack. HTML this deep is absurd; the limit only stops abuse. */
+#define HTML_MAX_DEPTH 1024
+
+static zend_result html_append_child(smart_str *buf, zval *value, uint32_t depth);
+
+/* Flatten a Traversable, coercing each yielded value recursively.
+ * Keys are ignored; only values render. */
+static zend_result html_append_traversable(smart_str *buf, zval *value, uint32_t depth)
+{
+	zend_class_entry *ce = Z_OBJCE_P(value);
+	zend_object_iterator *iter = ce->get_iterator(ce, value, /* by_ref */ 0);
+	zend_result result = SUCCESS;
+
+	if (iter == NULL || EG(exception)) {
+		return FAILURE;
+	}
+
+	if (iter->funcs->rewind) {
+		iter->funcs->rewind(iter);
+		if (EG(exception)) {
+			result = FAILURE;
+			goto done;
+		}
+	}
+
+	while (iter->funcs->valid(iter) == SUCCESS) {
+		if (EG(exception)) {
+			result = FAILURE;
+			break;
+		}
+
+		zval *element = iter->funcs->get_current_data(iter);
+		if (EG(exception) || element == NULL) {
+			result = FAILURE;
+			break;
+		}
+
+		if (html_append_child(buf, element, depth + 1) == FAILURE) {
+			result = FAILURE;
+			break;
+		}
+
+		iter->funcs->move_forward(iter);
+		if (EG(exception)) {
+			result = FAILURE;
+			break;
+		}
+	}
+
+done:
+	zend_iterator_dtor(iter);
+	return EG(exception) ? FAILURE : result;
+}
+
+/* Coerce and append a single child value.
+ * Returns FAILURE with an exception pending on an unrenderable value. */
+static zend_result html_append_child(smart_str *buf, zval *value, uint32_t depth)
+{
+	if (depth > HTML_MAX_DEPTH) {
+		zend_throw_error(NULL, "Maximum markup nesting depth of %d exceeded", HTML_MAX_DEPTH);
+		return FAILURE;
+	}
+
+	switch (Z_TYPE_P(value)) {
+		case IS_NULL:
+		case IS_FALSE:
+			/* renders as "" */
+			return SUCCESS;
+
+		case IS_TRUE:
+			/* (string) true === "1" */
+			smart_str_appendc(buf, '1');
+			return SUCCESS;
+
+		case IS_LONG:
+			smart_str_append_long(buf, Z_LVAL_P(value));
+			return SUCCESS;
+
+		case IS_DOUBLE: {
+			zend_string *s = zend_double_to_str(Z_DVAL_P(value));
+			smart_str_append(buf, s);
+			zend_string_release(s);
+			return SUCCESS;
+		}
+
+		case IS_STRING:
+			html_append_escaped(buf, Z_STR_P(value));
+			return SUCCESS;
+
+		case IS_ARRAY: {
+			/* flatten, coercing each element recursively */
+			zval *element;
+			ZEND_HASH_FOREACH_VAL(Z_ARRVAL_P(value), element) {
+				ZVAL_DEREF(element);
+				if (html_append_child(buf, element, depth + 1) == FAILURE) {
+					return FAILURE;
+				}
+			} ZEND_HASH_FOREACH_END();
+			return SUCCESS;
+		}
+
+		case IS_OBJECT: {
+			zend_class_entry *ce = Z_OBJCE_P(value);
+
+			/* Htmlable: already-safe HTML, passes through un-escaped. Resolved
+			 * through toHtml() to one of the internal node classes and then
+			 * serialized natively - never through __toString, so overriding a
+			 * component's string form cannot change what its markup renders as. */
+			if (instanceof_function(ce, html_ce_Htmlable)) {
+				zend_string *s = html_render_htmlable(value);
+				if (!s) {
+					return FAILURE;
+				}
+				smart_str_append(buf, s);
+				zend_string_release(s);
+				return SUCCESS;
+			}
+
+			/* Traversable: flatten, coercing each yielded value recursively. */
+			if (instanceof_function(ce, zend_ce_traversable)) {
+				return html_append_traversable(buf, value, depth);
+			}
+
+			/* Stringable: cast then escape like a string. */
+			if (instanceof_function(ce, zend_ce_stringable)) {
+				zend_string *s = zval_try_get_string(value);
+				if (!s) {
+					return FAILURE;
+				}
+				html_append_escaped(buf, s);
+				zend_string_release(s);
+				return SUCCESS;
+			}
+
+			zend_type_error(
+				"Object of class %s cannot be rendered as a markup child: "
+				"it implements none of Html\\Htmlable, Stringable, or Traversable",
+				ZSTR_VAL(ce->name));
+			return FAILURE;
+		}
+
+		case IS_REFERENCE:
+			return html_append_child(buf, Z_REFVAL_P(value), depth);
+
+		default:
+			zend_type_error(
+				"Value of type %s cannot be rendered as a markup child",
+				zend_zval_value_name(value));
+			return FAILURE;
+	}
+}
+
+/* Emit ` name="value"` into the buffer and release `value`. The `escape` flag
+ * is the one security-relevant decision in attribute emission: every value is
+ * escaped except an Htmlable's already-safe HTML (and numbers, which cannot
+ * contain escapable characters). Values are always serialized double-quoted -
+ * no unquoted output form exists. */
+static void html_append_attr_value(smart_str *buf, zend_string *name, zend_string *value, bool escape)
+{
+	smart_str_appendc(buf, ' ');
+	smart_str_append(buf, name);
+	smart_str_appendl(buf, "=\"", 2);
+	if (escape) {
+		html_append_escaped(buf, value);
+	} else {
+		smart_str_append(buf, value);
+	}
+	smart_str_appendc(buf, '"');
+	zend_string_release(value);
+}
+
+/* Coerce and append a single attribute value. */
+static zend_result html_append_attribute(smart_str *buf, zend_string *name, zval *value)
+{
+	switch (Z_TYPE_P(value)) {
+		case IS_NULL:
+		case IS_FALSE:
+			/* attribute omitted */
+			return SUCCESS;
+
+		case IS_TRUE:
+			/* bare boolean attribute */
+			smart_str_appendc(buf, ' ');
+			smart_str_append(buf, name);
+			return SUCCESS;
+
+		case IS_LONG:
+			html_append_attr_value(buf, name, zend_long_to_str(Z_LVAL_P(value)), false);
+			return SUCCESS;
+
+		case IS_DOUBLE:
+			html_append_attr_value(buf, name, zend_double_to_str(Z_DVAL_P(value)), false);
+			return SUCCESS;
+
+		case IS_STRING:
+			html_append_attr_value(buf, name, zend_string_copy(Z_STR_P(value)), true);
+			return SUCCESS;
+
+		case IS_OBJECT: {
+			zend_class_entry *value_ce = Z_OBJCE_P(value);
+
+			/* Htmlable (Html\raw(), Html\escape(), ...) is already-safe HTML and
+			 * passes through un-escaped, exactly as in child position - so
+			 * title={\Html\raw('&nbsp;')} emits the entity rather than
+			 * double-escaping it. The trust contract is the caller's: a raw
+			 * value containing '"' can break out of the attribute. */
+			if (instanceof_function(value_ce, html_ce_Htmlable)) {
+				zend_string *s = html_render_htmlable(value);
+				if (!s) {
+					return FAILURE;
+				}
+				html_append_attr_value(buf, name, s, false);
+				return SUCCESS;
+			}
+
+			if (instanceof_function(value_ce, zend_ce_stringable)) {
+				zend_string *s = zval_try_get_string(value);
+				if (!s) {
+					return FAILURE;
+				}
+				html_append_attr_value(buf, name, s, true);
+				return SUCCESS;
+			}
+			ZEND_FALLTHROUGH;
+		}
+
+		default:
+			/* arrays are reserved for a future class/style helper */
+			zend_type_error(
+				"Attribute \"%s\" value must be of type string|int|float|bool|null|Stringable, %s given",
+				ZSTR_VAL(name), zend_zval_value_name(value));
+			return FAILURE;
+	}
+}
+
+static zend_result html_append_attributes(smart_str *buf, HashTable *attributes)
+{
+	zend_string *name;
+	zval *value;
+
+	ZEND_HASH_FOREACH_STR_KEY_VAL(attributes, name, value) {
+		if (name == NULL) {
+			zend_type_error(
+				"Attribute names must be strings, integer given");
+			return FAILURE;
+		}
+		if (!html_is_valid_attr_name(name)) {
+			zend_value_error("Invalid attribute name \"%s\"", ZSTR_VAL(name));
+			return FAILURE;
+		}
+		ZVAL_DEREF(value);
+		if (html_append_attribute(buf, name, value) == FAILURE) {
+			return FAILURE;
+		}
+	} ZEND_HASH_FOREACH_END();
+
+	return SUCCESS;
+}
+
+/* Render an Html\Element to its smart_str buffer. */
+static zend_result html_render_element(smart_str *buf, zend_object *obj)
+{
+	zval rv_tag, rv_attrs, rv_children;
+	zval *tag = zend_read_property(html_ce_Element, obj, ZEND_STRL("tag"), /* silent */ true, &rv_tag);
+	zval *attributes = zend_read_property(html_ce_Element, obj, ZEND_STRL("attributes"), true, &rv_attrs);
+	zval *children = zend_read_property(html_ce_Element, obj, ZEND_STRL("children"), true, &rv_children);
+
+	ZVAL_DEREF(tag);
+	ZVAL_DEREF(attributes);
+	ZVAL_DEREF(children);
+
+	if (Z_TYPE_P(tag) != IS_STRING || Z_TYPE_P(attributes) != IS_ARRAY || Z_TYPE_P(children) != IS_ARRAY) {
+		zend_throw_error(NULL, "Html\\Element has not been initialized");
+		return FAILURE;
+	}
+
+	if (!html_is_valid_tag_name(Z_STR_P(tag))) {
+		zend_value_error("Invalid tag name \"%s\"", ZSTR_VAL(Z_STR_P(tag)));
+		return FAILURE;
+	}
+
+	smart_str_appendc(buf, '<');
+	smart_str_append(buf, Z_STR_P(tag));
+
+	if (html_append_attributes(buf, Z_ARRVAL_P(attributes)) == FAILURE) {
+		return FAILURE;
+	}
+
+	if (html_is_void_element(Z_STR_P(tag))) {
+		/* Clean HTML5 void element: no slash, no closing tag. Children would be
+		 * silently lost in serialization, so reject them outright. */
+		if (zend_hash_num_elements(Z_ARRVAL_P(children)) > 0) {
+			zend_throw_error(NULL,
+				"Void element <%s> cannot have children", ZSTR_VAL(Z_STR_P(tag)));
+			return FAILURE;
+		}
+		smart_str_appendc(buf, '>');
+		return SUCCESS;
+	}
+
+	smart_str_appendc(buf, '>');
+
+	if (html_append_child(buf, children, 0) == FAILURE) {
+		return FAILURE;
+	}
+
+	smart_str_appendl(buf, "</", 2);
+	smart_str_append(buf, Z_STR_P(tag));
+	smart_str_appendc(buf, '>');
+
+	return SUCCESS;
+}
+
+static zend_result html_render_fragment(smart_str *buf, zend_object *obj)
+{
+	zval rv;
+	zval *children = zend_read_property(html_ce_Fragment, obj, ZEND_STRL("children"), true, &rv);
+	ZVAL_DEREF(children);
+	if (Z_TYPE_P(children) != IS_ARRAY) {
+		zend_throw_error(NULL, "Html\\Fragment has not been initialized");
+		return FAILURE;
+	}
+	return html_append_child(buf, children, 0);
+}
+
+/* Bound the toHtml() resolution chain: a component may return another component,
+ * but a class whose toHtml() returns itself (or a cycle) must not spin forever. */
+#define HTML_TOHTML_MAX_DEPTH 64
+
+/* Resolve an Htmlable to one of the internal node classes (Element, Fragment,
+ * Raw) by calling toHtml() until it lands on one. On SUCCESS *node holds an
+ * owned reference; on FAILURE an exception is pending. */
+static zend_result html_resolve_htmlable(zval *value, zval *node)
+{
+	zval current;
+	ZVAL_COPY(&current, value);
+
+	for (uint32_t depth = 0; depth < HTML_TOHTML_MAX_DEPTH; depth++) {
+		zend_class_entry *ce = Z_OBJCE(current);
+		if (ce == html_ce_Element || ce == html_ce_Fragment || ce == html_ce_Raw) {
+			ZVAL_COPY_VALUE(node, &current);
+			return SUCCESS;
+		}
+
+		zval next;
+		ZVAL_UNDEF(&next);
+		zend_call_method_with_0_params(Z_OBJ(current), ce, NULL, "tohtml", &next);
+		zval_ptr_dtor(&current);
+		if (EG(exception)) {
+			zval_ptr_dtor(&next);
+			return FAILURE;
+		}
+		/* The declared return type already guarantees this for ordinary
+		 * methods; guard anyway (e.g. a __call-backed implementation). */
+		if (Z_TYPE(next) != IS_OBJECT || !instanceof_function(Z_OBJCE(next), html_ce_Htmlable)) {
+			zend_throw_error(NULL,
+				"%s::toHtml() did not return an Html\\Htmlable", ZSTR_VAL(ce->name));
+			zval_ptr_dtor(&next);
+			return FAILURE;
+		}
+		ZVAL_COPY_VALUE(&current, &next);
+	}
+
+	zend_throw_error(NULL,
+		"Maximum toHtml() resolution depth of %d exceeded (%s::toHtml() never produced an Html\\Element, Html\\Fragment, or Html\\Raw)",
+		HTML_TOHTML_MAX_DEPTH, ZSTR_VAL(Z_OBJCE(current)->name));
+	zval_ptr_dtor(&current);
+	return FAILURE;
+}
+
+/* Serialize one of the internal node classes to its final HTML string.
+ * Returns a new string, or NULL with an exception pending. */
+static zend_string *html_render_node(zval *node)
+{
+	zend_class_entry *ce = Z_OBJCE_P(node);
+
+	if (ce == html_ce_Raw) {
+		zval rv;
+		zval *html = zend_read_property(html_ce_Raw, Z_OBJ_P(node), ZEND_STRL("html"), true, &rv);
+		ZVAL_DEREF(html);
+		if (Z_TYPE_P(html) != IS_STRING) {
+			zend_throw_error(NULL, "Html\\Raw has not been initialized");
+			return NULL;
+		}
+		return zend_string_copy(Z_STR_P(html));
+	}
+
+	smart_str buf = {0};
+	zend_result rendered = (ce == html_ce_Element)
+		? html_render_element(&buf, Z_OBJ_P(node))
+		: html_render_fragment(&buf, Z_OBJ_P(node));
+	if (rendered == FAILURE) {
+		smart_str_free(&buf);
+		return NULL;
+	}
+	return smart_str_extract(&buf);
+}
+
+/* Render any Htmlable - a node class or a userland implementation - to its
+ * final HTML string: resolve through toHtml(), then serialize natively.
+ * Returns a new string, or NULL with an exception pending. */
+static zend_string *html_render_htmlable(zval *value)
+{
+	zval node;
+	if (html_resolve_htmlable(value, &node) == FAILURE) {
+		return NULL;
+	}
+	zend_string *result = html_render_node(&node);
+	zval_ptr_dtor(&node);
+	return result;
+}
+
+/* The default __toString() injected into userland Htmlable classes at
+ * class-link time (see html_implement_htmlable): render via toHtml(). */
+static ZEND_NAMED_FUNCTION(html_htmlable_default_tostring)
+{
+	ZEND_PARSE_PARAMETERS_NONE();
+
+	zend_string *s = html_render_htmlable(ZEND_THIS);
+	if (s == NULL) {
+		RETURN_THROWS();
+	}
+	RETURN_STR(s);
+}
+
+/* interface_gets_implemented handler for Html\Htmlable: give every userland
+ * implementing class a default __toString() unless it declares (or inherits)
+ * one of its own, so `echo $component` / `(string) $component` always work
+ * while toHtml() remains the only method a class must write.
+ *
+ * This runs during class linking, after the interface's methods were copied
+ * into the class but before zend_verify_abstract_class(), so replacing the
+ * inherited abstract __toString with a concrete function both satisfies
+ * Stringable and keeps the class instantiable. The injected function follows
+ * the engine's own precedent for enum cases()/from()/tryFrom(): an
+ * arena-allocated internal function inside a userland class
+ * (ZEND_ACC_ARENA_ALLOCATED is understood by class destruction, opcache
+ * persistence, and the inheritance cache). */
+static int html_implement_htmlable(zend_class_entry *iface, zend_class_entry *ce)
+{
+	if (ce->type != ZEND_USER_CLASS) {
+		/* An internal class must ship its own __toString (Element, Fragment,
+		 * and Raw do): injecting a request-arena-allocated default into a
+		 * permanent class would dangle across requests. */
+		if (ce->__tostring == NULL) {
+			zend_error_noreturn(E_CORE_ERROR,
+				"Internal class %s must declare __toString() to implement Html\\Htmlable",
+				ZSTR_VAL(ce->name));
+		}
+		return SUCCESS;
+	}
+
+	/* A __toString declared by the class, inherited from a parent class, or
+	 * flattened in from a trait wins; the default only fills the gap. When
+	 * the entry exists here but is abstract, it is the unimplemented
+	 * requirement inherited from Stringable through this interface. */
+	zval *zv = zend_hash_find(&ce->function_table, html_str_tostring_lc);
+	if (zv != NULL && !(((zend_function *) Z_PTR_P(zv))->common.fn_flags & ZEND_ACC_ABSTRACT)) {
+		return SUCCESS;
+	}
+
+	zend_internal_function *zif = zend_arena_calloc(&CG(arena), sizeof(zend_internal_function), 1);
+	zif->type = ZEND_INTERNAL_FUNCTION;
+	zif->module = EG(current_module);
+	zif->scope = ce;
+	zif->function_name = html_str_tostring;
+	zif->handler = html_htmlable_default_tostring;
+	zif->doc_comment = NULL;
+	zif->fn_flags = ZEND_ACC_PUBLIC | ZEND_ACC_HAS_RETURN_TYPE | ZEND_ACC_ARENA_ALLOCATED;
+	zif->arg_info = html_zarginfo_default_tostring + 1;
+	zif->T = ZEND_OBSERVER_ENABLED;
+	if (EG(active)) { /* linking at run-time (the normal case for user classes) */
+		if (CG(compiler_options) & ZEND_COMPILE_PRELOAD) {
+			zif->fn_flags |= ZEND_ACC_PRELOADED;
+		}
+		ZEND_MAP_PTR_INIT(zif->run_time_cache,
+			zend_arena_calloc(&CG(arena), 1, zend_internal_run_time_cache_reserved_size()));
+	} else {
+#ifdef ZTS
+		ZEND_MAP_PTR_NEW_STATIC(zif->run_time_cache);
+#else
+		ZEND_MAP_PTR_INIT(zif->run_time_cache, NULL);
+#endif
+	}
+
+	if (zv != NULL) {
+		/* Swap the abstract entry in place. The replaced pointer is the
+		 * interface's own method, owned by the interface - nothing to free,
+		 * and bypassing the hash dtor is exactly why this is not hash_update. */
+		Z_PTR_P(zv) = (zend_function *) zif;
+	} else {
+		/* The hook can also fire before method inheritance (a class
+		 * implementing an interface that extends Htmlable reaches here through
+		 * zend_do_inherit_interfaces); the later abstract-method copy then
+		 * finds this concrete implementation and accepts it. */
+		zend_hash_add_new_ptr(&ce->function_table, html_str_tostring_lc, zif);
+	}
+	ce->__tostring = (zend_function *) zif;
+
+	return SUCCESS;
+}
+
+/* Assigns a string to a (readonly) declared property during construction. */
+static void html_init_string_property(zend_class_entry *ce, zend_object *obj, const char *name, size_t name_len, zend_string *value)
+{
+	zval tmp;
+	ZVAL_STR_COPY(&tmp, value);
+	zend_update_property(ce, obj, name, name_len, &tmp);
+	zval_ptr_dtor(&tmp);
+}
+
+static void html_init_array_property(zend_class_entry *ce, zend_object *obj, const char *name, size_t name_len, zval *value /* may be NULL */)
+{
+	zval tmp;
+	if (value != NULL) {
+		ZVAL_COPY(&tmp, value);
+	} else {
+		ZVAL_EMPTY_ARRAY(&tmp);
+	}
+	zend_update_property(ce, obj, name, name_len, &tmp);
+	zval_ptr_dtor(&tmp);
+}
+
+PHP_METHOD(Html_Element, __construct)
+{
+	zend_string *tag;
+	zval *attributes = NULL, *children = NULL;
+
+	ZEND_PARSE_PARAMETERS_START(1, 3)
+		Z_PARAM_STR(tag)
+		Z_PARAM_OPTIONAL
+		Z_PARAM_ARRAY(attributes)
+		Z_PARAM_ARRAY(children)
+	ZEND_PARSE_PARAMETERS_END();
+
+	zend_object *obj = Z_OBJ_P(ZEND_THIS);
+	html_init_string_property(html_ce_Element, obj, ZEND_STRL("tag"), tag);
+	html_init_array_property(html_ce_Element, obj, ZEND_STRL("attributes"), attributes);
+	html_init_array_property(html_ce_Element, obj, ZEND_STRL("children"), children);
+}
+
+/* The node classes are the base cases of toHtml() resolution: each returns
+ * itself. */
+PHP_METHOD(Html_Element, toHtml)
+{
+	ZEND_PARSE_PARAMETERS_NONE();
+	RETURN_COPY(ZEND_THIS);
+}
+
+PHP_METHOD(Html_Fragment, toHtml)
+{
+	ZEND_PARSE_PARAMETERS_NONE();
+	RETURN_COPY(ZEND_THIS);
+}
+
+PHP_METHOD(Html_Raw, toHtml)
+{
+	ZEND_PARSE_PARAMETERS_NONE();
+	RETURN_COPY(ZEND_THIS);
+}
+
+/* Shared __toString() body for the three node classes: serialize through
+ * html_render_node, the same function child-position rendering uses, so
+ * `(string) $el` and rendering $el as a child can never diverge. */
+static void html_node_tostring(INTERNAL_FUNCTION_PARAMETERS)
+{
+	ZEND_PARSE_PARAMETERS_NONE();
+
+	zend_string *s = html_render_node(ZEND_THIS);
+	if (s == NULL) {
+		RETURN_THROWS();
+	}
+	RETURN_STR(s);
+}
+
+PHP_METHOD(Html_Element, __toString)
+{
+	html_node_tostring(INTERNAL_FUNCTION_PARAM_PASSTHRU);
+}
+
+PHP_METHOD(Html_Fragment, __construct)
+{
+	zval *children = NULL;
+
+	ZEND_PARSE_PARAMETERS_START(0, 1)
+		Z_PARAM_OPTIONAL
+		Z_PARAM_ARRAY(children)
+	ZEND_PARSE_PARAMETERS_END();
+
+	html_init_array_property(html_ce_Fragment, Z_OBJ_P(ZEND_THIS), ZEND_STRL("children"), children);
+}
+
+PHP_METHOD(Html_Fragment, __toString)
+{
+	html_node_tostring(INTERNAL_FUNCTION_PARAM_PASSTHRU);
+}
+
+PHP_METHOD(Html_Raw, __construct)
+{
+	zend_string *html;
+
+	ZEND_PARSE_PARAMETERS_START(1, 1)
+		Z_PARAM_STR(html)
+	ZEND_PARSE_PARAMETERS_END();
+
+	html_init_string_property(html_ce_Raw, Z_OBJ_P(ZEND_THIS), ZEND_STRL("html"), html);
+}
+
+PHP_METHOD(Html_Raw, __toString)
+{
+	html_node_tostring(INTERNAL_FUNCTION_PARAM_PASSTHRU);
+}
+
+PHP_METHOD(Html_LazyFragment, __construct)
+{
+	zval *thunk;
+
+	ZEND_PARSE_PARAMETERS_START(1, 1)
+		Z_PARAM_OBJECT_OF_CLASS(thunk, zend_ce_closure)
+	ZEND_PARSE_PARAMETERS_END();
+
+	html_lazy_fragment *lf = html_lazy_fragment_from_obj(Z_OBJ_P(ZEND_THIS));
+	ZVAL_COPY(&lf->thunk, thunk);
+}
+
+/* Resolve the deferred body once and memoize it: toHtml() is the seam the render
+ * path already calls, so a component that never renders the slot never runs the
+ * thunk. */
+PHP_METHOD(Html_LazyFragment, toHtml)
+{
+	ZEND_PARSE_PARAMETERS_NONE();
+
+	html_lazy_fragment *lf = html_lazy_fragment_from_obj(Z_OBJ_P(ZEND_THIS));
+
+	if (Z_TYPE(lf->resolved) == IS_UNDEF) {
+		if (Z_TYPE(lf->thunk) != IS_OBJECT) {
+			zend_throw_error(NULL, "Html\\LazyFragment has not been initialized");
+			RETURN_THROWS();
+		}
+
+		zend_fcall_info fci;
+		zend_fcall_info_cache fcc;
+		char *error = NULL;
+		if (zend_fcall_info_init(&lf->thunk, 0, &fci, &fcc, NULL, &error) == FAILURE) {
+			zend_throw_error(NULL, "Html\\LazyFragment thunk is not callable%s%s",
+				error ? ": " : "", error ? error : "");
+			if (error) {
+				efree(error);
+			}
+			RETURN_THROWS();
+		}
+		if (error) {
+			efree(error);
+		}
+
+		zval result;
+		ZVAL_UNDEF(&result);
+		fci.retval = &result;
+		zend_call_function(&fci, &fcc);
+
+		if (EG(exception)) {
+			zval_ptr_dtor(&result);
+			RETURN_THROWS();
+		}
+		if (Z_TYPE(result) != IS_OBJECT
+				|| !instanceof_function(Z_OBJCE(result), html_ce_Htmlable)) {
+			zend_throw_error(NULL, "Html\\LazyFragment thunk must return an Html\\Htmlable");
+			zval_ptr_dtor(&result);
+			RETURN_THROWS();
+		}
+
+		/* Move ownership into the memo. */
+		ZVAL_COPY_VALUE(&lf->resolved, &result);
+	}
+
+	RETURN_COPY(&lf->resolved);
+}
+
+PHP_METHOD(Html_LazyFragment, __toString)
+{
+	/* Identical to the default __toString() injected into userland Htmlable
+	 * classes: resolve through toHtml() (running/memoizing the thunk), then
+	 * serialize. Declared explicitly because the injection skips internal
+	 * classes (see html_implement_htmlable). */
+	html_htmlable_default_tostring(INTERNAL_FUNCTION_PARAM_PASSTHRU);
+}
+
+/* Build an Html\Raw wrapping the given (already-final) HTML string. */
+static void html_return_raw(zval *return_value, zend_string *html)
+{
+	object_init_ex(return_value, html_ce_Raw);
+	html_init_string_property(html_ce_Raw, Z_OBJ_P(return_value), ZEND_STRL("html"), html);
+}
+
+PHP_FUNCTION(Html_raw)
+{
+	zend_string *html;
+
+	ZEND_PARSE_PARAMETERS_START(1, 1)
+		Z_PARAM_STR(html)
+	ZEND_PARSE_PARAMETERS_END();
+
+	html_return_raw(return_value, html);
+}
+
+PHP_FUNCTION(Html_escape)
+{
+	zend_string *text;
+
+	ZEND_PARSE_PARAMETERS_START(1, 1)
+		Z_PARAM_STR(text)
+	ZEND_PARSE_PARAMETERS_END();
+
+	zend_string *escaped = html_escape_string(ZSTR_VAL(text), ZSTR_LEN(text));
+	html_return_raw(return_value, escaped);
+	zend_string_release(escaped);
+}
+
+/* Merge explicit props with body content routed via a #[Html\Slot] parameter
+ * attribute, producing the named-argument array for a component dispatch.
+ * Returns a new array (caller releases) or NULL with a pending exception. */
+static HashTable *html_route_component_args(
+	zend_function *fn, HashTable *props, zval *slot)
+{
+	HashTable *args = zend_new_array(props ? zend_hash_num_elements(props) : 0);
+	zend_string *slot_param = NULL;       /* param name marked #[Html\Slot] */
+
+	/* 1. explicit props become named arguments */
+	if (props) {
+		zend_string *key;
+		zval *val;
+		ZEND_HASH_FOREACH_STR_KEY_VAL(props, key, val) {
+			if (key == NULL) {
+				zend_throw_error(NULL, "Component props must use string keys");
+				goto fail;
+			}
+			Z_TRY_ADDREF_P(val);
+			zend_hash_update(args, key, val);
+		} ZEND_HASH_FOREACH_END();
+	}
+
+	/* 2. discover the slot parameter from a #[Html\Slot] attribute */
+	if (fn && fn->common.attributes) {
+		for (uint32_t i = 0; i < fn->common.num_args; i++) {
+			zend_attribute *attr = zend_get_parameter_attribute_str(
+				fn->common.attributes, ZEND_STRL("html\\slot"), i);
+			if (attr == NULL) {
+				continue;
+			}
+			if (slot_param != NULL) {
+				zend_throw_error(NULL, "Component has more than one #[Html\\Slot] parameter");
+				goto fail;
+			}
+			slot_param = fn->common.arg_info[i].name;
+		}
+
+		/* A slot is a single value, so it cannot fill a variadic parameter
+		 * (which num_args excludes above); reject rather than silently ignore. */
+		if (fn->common.fn_flags & ZEND_ACC_VARIADIC
+				&& zend_get_parameter_attribute_str(
+					fn->common.attributes, ZEND_STRL("html\\slot"), fn->common.num_args) != NULL) {
+			zend_throw_error(NULL, "#[Html\\Slot] cannot be applied to a variadic parameter");
+			goto fail;
+		}
+	}
+
+	/* 3. route the body slot */
+	if (slot != NULL) {
+		if (slot_param == NULL) {
+			zend_throw_error(NULL, "Component received body content but has no #[Html\\Slot] parameter");
+			goto fail;
+		}
+		if (zend_hash_exists(args, slot_param)) {
+			zend_throw_error(NULL, "Parameter $%s is filled by both an attribute and body content", ZSTR_VAL(slot_param));
+			goto fail;
+		}
+		Z_ADDREF_P(slot);
+		zend_hash_add_new(args, slot_param, slot);
+	}
+
+	return args;
+
+fail:
+	zend_array_release(args);
+	return NULL;
+}
+
+/* One entry in a hook list: the callable plus an optional component scope.
+ * A NULL scope means the hook runs for every component; a non-NULL scope
+ * limits it to the one component whose resolved name matches (the same name
+ * the hook receives as its string argument). Scoped hooks let the dispatch
+ * skip non-matching handlers in C, before any userland call. */
+typedef struct {
+	zval callable;
+	zend_string *component;
+} html_handler;
+
+static void html_handler_dtor(zval *zv)
+{
+	html_handler *handler = Z_PTR_P(zv);
+	zval_ptr_dtor(&handler->callable);
+	if (handler->component != NULL) {
+		zend_string_release(handler->component);
+	}
+	efree(handler);
+}
+
+/* Component names are case-insensitive everywhere PHP resolves them (classes,
+ * functions, methods), so scope matching is too. */
+static zend_always_inline bool html_handler_matches(const html_handler *handler, zend_string *name)
+{
+	return handler->component == NULL || zend_string_equals_ci(handler->component, name);
+}
+
+/* Resolved component names never carry a leading backslash, but "\App\Card"
+ * is how userland habitually writes an FQCN; accept both. */
+static zend_string *html_normalize_component_scope(zend_string *component)
+{
+	if (ZSTR_LEN(component) > 0 && ZSTR_VAL(component)[0] == '\\') {
+		return zend_string_init(ZSTR_VAL(component) + 1, ZSTR_LEN(component) - 1, 0);
+	}
+	return zend_string_copy(component);
+}
+
+/* Append a callable to one of the request-scoped handler lists (allocating it on
+ * first use). Adds its own reference to the handler. Throws a TypeError and
+ * returns false when the value is not callable (like spl_autoload_register). */
+static bool html_register_handler(HashTable **list, zval *callable, zend_string *component, uint32_t arg_num)
+{
+	if (!zend_is_callable(callable, 0, NULL)) {
+		zend_argument_type_error(arg_num, "must be a valid callback");
+		return false;
+	}
+	if (*list == NULL) {
+		ALLOC_HASHTABLE(*list);
+		zend_hash_init(*list, 4, NULL, html_handler_dtor, 0);
+	}
+	html_handler *handler = emalloc(sizeof(html_handler));
+	ZVAL_COPY(&handler->callable, callable);
+	handler->component = component != NULL ? html_normalize_component_scope(component) : NULL;
+	zend_hash_next_index_insert_ptr(*list, handler);
+	return true;
+}
+
+/* Remove the first handler identical to the given callable *and* registered
+ * with the same scope (unscoped only matches unscoped). Returns whether one
+ * matched. Order of the remaining handlers is preserved. */
+static bool html_unregister_handler(HashTable *list, zval *callable, zend_string *component)
+{
+	if (list == NULL) {
+		return false;
+	}
+	zend_string *scope = component != NULL ? html_normalize_component_scope(component) : NULL;
+	bool removed = false;
+	zend_ulong idx;
+	html_handler *handler;
+	ZEND_HASH_FOREACH_NUM_KEY_PTR(list, idx, handler) {
+		if (!zend_is_identical(&handler->callable, callable)) {
+			continue;
+		}
+		if ((handler->component == NULL) != (scope == NULL)
+				|| (scope != NULL && !zend_string_equals_ci(handler->component, scope))) {
+			continue;
+		}
+		removed = zend_hash_index_del(list, idx) == SUCCESS;
+		break;
+	} ZEND_HASH_FOREACH_END();
+	if (scope != NULL) {
+		zend_string_release(scope);
+	}
+	return removed;
+}
+
+/* A fresh, always-refcounted array copy of the routed component arguments (or an
+ * empty array when there are none), safe to hand to a userland factory.
+ * Duplicating avoids force-refcounting a possibly-immutable borrowed array (an
+ * empty `[]` literal is the shared, read-only zend_empty_array) and stops a
+ * handler from mutating the engine's internal argument array. */
+static zend_array *html_args_for_handler(HashTable *args)
+{
+	return args != NULL ? zend_array_dup(args) : zend_new_array(0);
+}
+
+/* Snapshot the handlers in `chain` whose scope matches `name`, or NULL when
+ * none match. No user code runs during the scan, so iterating the live table
+ * is safe; the snapshot exists because the handlers themselves may
+ * (un)register hooks, which would otherwise rehash the table under a live
+ * iterator (a registration made during dispatch takes effect from the next
+ * dispatch). A fully non-matching dispatch allocates nothing. */
+static HashTable *html_matching_handlers(HashTable *chain, zend_string *name)
+{
+	HashTable *snapshot = NULL;
+	html_handler *handler;
+	ZEND_HASH_FOREACH_PTR(chain, handler) {
+		if (!html_handler_matches(handler, name)) {
+			continue;
+		}
+		if (snapshot == NULL) {
+			ALLOC_HASHTABLE(snapshot);
+			zend_hash_init(snapshot, 4, NULL, ZVAL_PTR_DTOR, 0);
+		}
+		Z_TRY_ADDREF(handler->callable);
+		zend_hash_next_index_insert_new(snapshot, &handler->callable);
+	} ZEND_HASH_FOREACH_END();
+	return snapshot;
+}
+
+/* Run a handler chain (component factories). Each in-scope handler
+ * is called as `handler(name, args)`; the first to return a non-null value
+ * takes over the dispatch. Returns 1 with *result set (owned) when a handler
+ * took it, 0 when every handler deferred (or none are in scope), or -1 when a
+ * handler threw. The userland args copy is only made once a handler is
+ * actually about to run. */
+static int html_run_handler_chain(HashTable *chain, zend_string *name, HashTable *args, zval *result)
+{
+	if (chain == NULL) {
+		return 0;
+	}
+	HashTable *snapshot = html_matching_handlers(chain, name);
+	if (snapshot == NULL) {
+		return 0;
+	}
+	zval name_zv, args_zv;
+	ZVAL_STR_COPY(&name_zv, name);
+	ZVAL_ARR(&args_zv, html_args_for_handler(args));
+	int outcome = 0;
+	zval *handler;
+	ZEND_HASH_FOREACH_VAL(snapshot, handler) {
+		zval params[2], ret;
+		ZVAL_COPY(&params[0], &name_zv);
+		ZVAL_COPY(&params[1], &args_zv);
+		ZVAL_UNDEF(&ret);
+		zend_result called = call_user_function(NULL, NULL, handler, &ret, 2, params);
+		zval_ptr_dtor(&params[0]);
+		zval_ptr_dtor(&params[1]);
+		if (called != SUCCESS || EG(exception)) {
+			zval_ptr_dtor(&ret);
+			outcome = -1;
+			break;
+		}
+		if (Z_TYPE(ret) != IS_NULL) {
+			ZVAL_COPY_VALUE(result, &ret);
+			outcome = 1;
+			break;
+		}
+		zval_ptr_dtor(&ret);
+	} ZEND_HASH_FOREACH_END();
+	zval_ptr_dtor(&name_zv);
+	zval_ptr_dtor(&args_zv);
+	zend_hash_release(snapshot);
+	return outcome;
+}
+
+PHP_FUNCTION(Html_register_component_factory)
+{
+	zval *factory;
+	zend_string *component = NULL;
+	ZEND_PARSE_PARAMETERS_START(1, 2)
+		Z_PARAM_ZVAL(factory)
+		Z_PARAM_OPTIONAL
+		Z_PARAM_STR_OR_NULL(component)
+	ZEND_PARSE_PARAMETERS_END();
+
+	if (!html_register_handler(&HTML_G(component_factories), factory, component, 1)) {
+		RETURN_THROWS();
+	}
+}
+
+PHP_FUNCTION(Html_unregister_component_factory)
+{
+	zval *factory;
+	zend_string *component = NULL;
+	ZEND_PARSE_PARAMETERS_START(1, 2)
+		Z_PARAM_ZVAL(factory)
+		Z_PARAM_OPTIONAL
+		Z_PARAM_STR_OR_NULL(component)
+	ZEND_PARSE_PARAMETERS_END();
+
+	RETURN_BOOL(html_unregister_handler(HTML_G(component_factories), factory, component));
+}
+
+PHP_FUNCTION(Html_register_component_decorator)
+{
+	zval *decorator;
+	zend_string *component = NULL;
+	ZEND_PARSE_PARAMETERS_START(1, 2)
+		Z_PARAM_ZVAL(decorator)
+		Z_PARAM_OPTIONAL
+		Z_PARAM_STR_OR_NULL(component)
+	ZEND_PARSE_PARAMETERS_END();
+
+	if (!html_register_handler(&HTML_G(component_decorators), decorator, component, 1)) {
+		RETURN_THROWS();
+	}
+}
+
+PHP_FUNCTION(Html_unregister_component_decorator)
+{
+	zval *decorator;
+	zend_string *component = NULL;
+	ZEND_PARSE_PARAMETERS_START(1, 2)
+		Z_PARAM_ZVAL(decorator)
+		Z_PARAM_OPTIONAL
+		Z_PARAM_STR_OR_NULL(component)
+	ZEND_PARSE_PARAMETERS_END();
+
+	RETURN_BOOL(html_unregister_handler(HTML_G(component_decorators), decorator, component));
+}
+
+/* Run the produced Html\Htmlable through the decorator chain: each decorator is
+ * called as `decorator(Html\Htmlable $rendered, string $component)` and returns a
+ * possibly-wrapped Html\Htmlable, composed in registration order. Updates *html in
+ * place; on failure returns false with an exception pending and *html released. */
+static bool html_apply_decorators(zend_string *component, zval *html)
+{
+	if (HTML_G(component_decorators) == NULL) {
+		return true;
+	}
+	HashTable *decorators = html_matching_handlers(HTML_G(component_decorators), component);
+	if (decorators == NULL) {
+		return true;
+	}
+	zval name_zv;
+	ZVAL_STR_COPY(&name_zv, component);
+
+	zval *decorator;
+	ZEND_HASH_FOREACH_VAL(decorators, decorator) {
+		zval params[2], decorated;
+		ZVAL_COPY(&params[0], html);
+		ZVAL_COPY(&params[1], &name_zv);
+		ZVAL_UNDEF(&decorated);
+		zend_result called = call_user_function(NULL, NULL, decorator, &decorated, 2, params);
+		zval_ptr_dtor(&params[0]);
+		zval_ptr_dtor(&params[1]);
+		if (called != SUCCESS || EG(exception)) {
+			zval_ptr_dtor(&decorated);
+			goto fail;
+		}
+		if (Z_TYPE(decorated) != IS_OBJECT || !instanceof_function(Z_OBJCE(decorated), html_ce_Htmlable)) {
+			zend_throw_error(NULL,
+				"Component decorator for <%s> did not return an Html\\Htmlable",
+				ZSTR_VAL(component));
+			zval_ptr_dtor(&decorated);
+			goto fail;
+		}
+		zval_ptr_dtor(html);
+		ZVAL_COPY_VALUE(html, &decorated);
+	} ZEND_HASH_FOREACH_END();
+
+	zend_array_release(decorators);
+	zval_ptr_dtor(&name_zv);
+	return true;
+
+fail:
+	zend_array_release(decorators);
+	zval_ptr_dtor(&name_zv);
+	zval_ptr_dtor(html);
+	return false;
+}
+
+/* Resolve a "Class::method" component to a public static user-defined method.
+ * On FAILURE an exception is pending. */
+static zend_result html_resolve_static_method(
+	zend_string *component, const char *sep, zend_class_entry **ce_out, zend_function **fn_out)
+{
+	size_t class_len = sep - ZSTR_VAL(component);
+	zend_string *class_name = zend_string_init(ZSTR_VAL(component), class_len, 0);
+	zend_string *method_name = zend_string_init(sep + 2, ZSTR_LEN(component) - class_len - 2, 0);
+	zend_class_entry *ce;
+	zend_function *fn;
+	zend_result result = FAILURE;
+
+	ce = zend_lookup_class(class_name);
+	if (ce == NULL) {
+		zend_throw_error(NULL, "Component class \"%s\" not found", ZSTR_VAL(class_name));
+		goto out;
+	}
+
+	zend_string *lc_method = zend_string_tolower(method_name);
+	fn = zend_hash_find_ptr(&ce->function_table, lc_method);
+	zend_string_release(lc_method);
+
+	if (fn == NULL) {
+		zend_throw_error(NULL, "Component method %s::%s() not found",
+			ZSTR_VAL(class_name), ZSTR_VAL(method_name));
+		goto out;
+	}
+
+	/* The engine calls the method from no particular scope with no $this, so
+	 * only a public, non-abstract *static* method is a valid component target
+	 * (a raw function-table hit bypasses the VM's own checks). Internal
+	 * methods are rejected like internal functions. */
+	if (!(fn->common.fn_flags & ZEND_ACC_STATIC)
+			|| !(fn->common.fn_flags & ZEND_ACC_PUBLIC)
+			|| (fn->common.fn_flags & ZEND_ACC_ABSTRACT)
+			|| fn->type == ZEND_INTERNAL_FUNCTION) {
+		zend_throw_error(NULL,
+			"Component method %s::%s() must be a public static user-defined method",
+			ZSTR_VAL(class_name), ZSTR_VAL(method_name));
+		goto out;
+	}
+
+	*ce_out = ce;
+	*fn_out = fn;
+	result = SUCCESS;
+
+out:
+	zend_string_release(class_name);
+	zend_string_release(method_name);
+	return result;
+}
+
+/* Dispatch a static-method component: call it and require an Html\Htmlable
+ * back. Same contract as html_dispatch_new(): the result goes into *result on
+ * SUCCESS, an exception is pending on FAILURE, and `args` is never released. */
+static zend_result html_dispatch_call(
+	zend_function *fn, zend_class_entry *called_scope, zend_string *component,
+	HashTable *args, zval *result)
+{
+	zval ret;
+	ZVAL_UNDEF(&ret);
+	zend_call_known_function(fn, NULL, called_scope, &ret, 0, NULL, args);
+	if (EG(exception)) {
+		zval_ptr_dtor(&ret);
+		return FAILURE;
+	}
+	if (Z_TYPE(ret) != IS_OBJECT || !instanceof_function(Z_OBJCE(ret), html_ce_Htmlable)) {
+		zend_throw_error(NULL,
+			"Component \"%s\" did not return an Html\\Htmlable", ZSTR_VAL(component));
+		zval_ptr_dtor(&ret);
+		return FAILURE;
+	}
+	ZVAL_COPY_VALUE(result, &ret);
+	return SUCCESS;
+}
+
+/* Dispatch a class component: a registered factory may construct it (e.g.
+ * through a DI container) before the engine's own `new`. On SUCCESS the
+ * produced object is in *result; on FAILURE an exception is pending. Never
+ * releases `args` - the caller owns it. */
+static zend_result html_dispatch_new(
+	zend_class_entry *ce, zend_function *ctor, HashTable *args, zval *result)
+{
+	if (HTML_G(component_factories) != NULL) {
+		zval obj;
+		int handled = html_run_handler_chain(HTML_G(component_factories), ce->name, args, &obj);
+		if (handled < 0) {
+			return FAILURE;
+		}
+		if (handled) {
+			if (Z_TYPE(obj) != IS_OBJECT || !instanceof_function(Z_OBJCE(obj), ce)) {
+				zend_throw_error(NULL,
+					"Component factory for <%s> did not return an instance of it or null",
+					ZSTR_VAL(ce->name));
+				zval_ptr_dtor(&obj);
+				return FAILURE;
+			}
+			ZVAL_COPY_VALUE(result, &obj);
+			return SUCCESS;
+		}
+	}
+
+	/* Mirror what `new` enforces: the engine constructs from no particular
+	 * scope, so the constructor must be public; and a class without a
+	 * constructor cannot receive props/slots (dropping them silently would
+	 * hide the mistake). */
+	if (ctor != NULL && !(ctor->common.fn_flags & ZEND_ACC_PUBLIC)) {
+		zend_throw_error(NULL, "Component class \"%s\" has a non-public constructor",
+			ZSTR_VAL(ce->name));
+		return FAILURE;
+	}
+	if (ctor == NULL && args != NULL && zend_hash_num_elements(args) > 0) {
+		zend_throw_error(NULL,
+			"Component class \"%s\" has no constructor, so it cannot accept attributes or slots",
+			ZSTR_VAL(ce->name));
+		return FAILURE;
+	}
+
+	zval obj;
+	if (object_init_ex(&obj, ce) != SUCCESS) {
+		return FAILURE;
+	}
+	if (ctor != NULL) {
+		zval ctor_ret;
+		ZVAL_UNDEF(&ctor_ret);
+		zend_call_known_function(ctor, Z_OBJ(obj), ce, &ctor_ret, 0, NULL, args);
+		zval_ptr_dtor(&ctor_ret);
+		if (EG(exception)) {
+			zval_ptr_dtor(&obj);
+			return FAILURE;
+		}
+	}
+	ZVAL_COPY_VALUE(result, &obj);
+	return SUCCESS;
+}
+
+/* The body of Html\render_component(), shared with Html\render_dynamic()'s
+ * component path. Same contract as a PHP_FUNCTION body: the produced
+ * Html\Htmlable goes into *return_value, or an exception is left pending. */
+static void html_render_component_impl(
+	zend_string *component, HashTable *props, zend_object *slot_obj,
+	zval *return_value)
+{
+	/* Resolve the component to a dispatch target. This is the second
+	 * stage of a two-stage resolution: the compiler already resolved the *name*
+	 * against use/namespace (see zend_ast_create_markup_component in
+	 * Zend/zend_markup.c); here that name resolves to a class implementing
+	 * Html\Htmlable (instantiated) or, for "Class::method", a public static
+	 * method (called). Class resolution is the only name machinery involved -
+	 * plain functions are not components (see the RFC's Future Scope). */
+	zend_function *fn;
+	zend_class_entry *ce;
+	bool is_new;
+
+	const char *end = ZSTR_VAL(component) + ZSTR_LEN(component);
+	const char *sep = zend_memnstr(ZSTR_VAL(component), "::", 2, end);
+
+	if (sep != NULL) {
+		/* "Class::method" - an explicit static-method component. */
+		if (html_resolve_static_method(component, sep, &ce, &fn) == FAILURE) {
+			RETURN_THROWS();
+		}
+		is_new = false;
+	} else {
+		ce = zend_lookup_class(component);
+		if (ce == NULL || !instanceof_function(ce, html_ce_Htmlable)) {
+			zend_throw_error(NULL,
+				"\"%s\" is not a component: no such class implementing Html\\Htmlable",
+				ZSTR_VAL(component));
+			RETURN_THROWS();
+		}
+		fn = ce->constructor;
+		is_new = true;
+	}
+
+	/* Build the named-argument array (props + routed slots). */
+	zval slot_zv;
+	zval *slot_ptr = NULL;
+	if (slot_obj != NULL) {
+		ZVAL_OBJ(&slot_zv, slot_obj);
+		slot_ptr = &slot_zv;
+	}
+
+	/* Fast path: with no slot content to route and no #[Html\Slot] parameters to
+	 * inspect, the named-argument array is exactly $props - pass it through
+	 * directly (borrowed) instead of allocating and copying a new HashTable.
+	 * Each path validates prop keys exactly once: here on the borrowed table
+	 * (an integer key would silently become a positional argument in
+	 * zend_call_known_function), or in html_route_component_args as it copies. */
+	HashTable *args;
+	bool owns_args;
+	if (slot_ptr == NULL
+			&& (fn == NULL || fn->common.attributes == NULL)) {
+		if (props != NULL) {
+			zend_string *key;
+			ZEND_HASH_FOREACH_STR_KEY(props, key) {
+				if (key == NULL) {
+					zend_throw_error(NULL, "Component props must use string keys");
+					RETURN_THROWS();
+				}
+			} ZEND_HASH_FOREACH_END();
+		}
+		args = props; /* may be NULL when no attributes were given */
+		owns_args = false;
+	} else {
+		args = html_route_component_args(fn, props, slot_ptr);
+		if (args == NULL) {
+			RETURN_THROWS();
+		}
+		owns_args = true;
+	}
+
+	/* Dispatch: either path produces the component's Html\Htmlable into `result`
+	 * and never releases `args`, so the single release below covers every
+	 * outcome. */
+	zval result;
+	ZVAL_UNDEF(&result);
+	zend_result dispatched = is_new
+		? html_dispatch_new(ce, fn, args, &result)
+		: html_dispatch_call(fn, ce, component, args, &result);
+
+	if (owns_args) {
+		zend_array_release(args);
+	}
+	if (dispatched == FAILURE) {
+		RETURN_THROWS();
+	}
+
+	/* Decorators wrap the produced Htmlable uniformly, whatever its kind. A
+	 * class component's name is the resolved ce->name (which may differ in
+	 * case/aliasing from the tag); a static method's is the "Class::method"
+	 * string, whose class part the compiler already resolved. */
+	if (!html_apply_decorators(is_new ? ce->name : component, &result)) {
+		RETURN_THROWS();
+	}
+
+	RETURN_COPY_VALUE(&result);
+}
+
+PHP_FUNCTION(Html_render_component)
+{
+	zend_string *component;
+	HashTable *props = NULL;
+	zend_object *slot_obj = NULL;
+
+	ZEND_PARSE_PARAMETERS_START(1, 3)
+		Z_PARAM_STR(component)
+		Z_PARAM_OPTIONAL
+		Z_PARAM_ARRAY_HT(props)
+		Z_PARAM_OBJ_OF_CLASS_OR_NULL(slot_obj, html_ce_Htmlable)
+	ZEND_PARSE_PARAMETERS_END();
+
+	html_render_component_impl(component, props, slot_obj, return_value);
+}
+
+/* The runtime target of a dynamic tag `<$tag …>…</$tag>`. The value
+ * decides at runtime exactly what a static tag name decides at compile time,
+ * by the same classification rule (zend_markup_name_is_component): an
+ * uppercase first character, a "\", or a "::" dispatches as a component -
+ * through the full render_component machinery, hooks and decorators included -
+ * and anything else constructs a literal \Html\Element. Exposed as a public
+ * function like render_component, so the rule is directly testable. */
+PHP_FUNCTION(Html_render_dynamic)
+{
+	zend_string *tag;
+	zval *attributes = NULL;
+	zval *children = NULL;
+
+	/* The array parameters are taken as zvals, not raw HashTables: they are
+	 * forwarded to constructor calls below, and a fresh ZVAL_ARR of a borrowed
+	 * table would mark an immutable array literal (e.g. a compiled []) as
+	 * refcounted, making the callee addref read-only memory. The caller's
+	 * zvals carry the correct type flags. */
+	ZEND_PARSE_PARAMETERS_START(1, 3)
+		Z_PARAM_STR(tag)
+		Z_PARAM_OPTIONAL
+		Z_PARAM_ARRAY(attributes)
+		Z_PARAM_ARRAY(children)
+	ZEND_PARSE_PARAMETERS_END();
+
+	if (ZSTR_LEN(tag) == 0) {
+		zend_argument_value_error(1, "cannot be empty");
+		RETURN_THROWS();
+	}
+
+	bool have_children = children != NULL && zend_hash_num_elements(Z_ARRVAL_P(children)) > 0;
+
+	if (zend_markup_name_is_component(tag)) {
+		/* Body children become the slot Fragment, exactly as the compiler builds
+		 * one for a static component tag. A dynamic component name is already
+		 * fully qualified (e.g. Foo::class, or "Class::method" for a static
+		 * method) and resolves directly. */
+		zval slot;
+		zend_object *slot_obj = NULL;
+		ZVAL_UNDEF(&slot);
+		if (have_children) {
+			if (object_init_ex(&slot, html_ce_Fragment) != SUCCESS) {
+				RETURN_THROWS();
+			}
+			slot_obj = Z_OBJ(slot);
+			zend_call_known_function(html_ce_Fragment->constructor, slot_obj,
+				html_ce_Fragment, NULL, 1, children, NULL);
+			if (EG(exception)) {
+				zval_ptr_dtor(&slot);
+				RETURN_THROWS();
+			}
+		}
+		html_render_component_impl(tag,
+			attributes != NULL ? Z_ARRVAL_P(attributes) : NULL, slot_obj,
+			return_value);
+		zval_ptr_dtor(&slot);
+		return;
+	}
+
+	zval args[3];
+	ZVAL_STR(&args[0], tag);
+	if (attributes != NULL) {
+		ZVAL_COPY_VALUE(&args[1], attributes);
+	} else {
+		ZVAL_EMPTY_ARRAY(&args[1]);
+	}
+	if (children != NULL) {
+		ZVAL_COPY_VALUE(&args[2], children);
+	} else {
+		ZVAL_EMPTY_ARRAY(&args[2]);
+	}
+
+	if (object_init_ex(return_value, html_ce_Element) != SUCCESS) {
+		RETURN_THROWS();
+	}
+	zend_call_known_function(html_ce_Element->constructor, Z_OBJ_P(return_value),
+		html_ce_Element, NULL, 3, args, NULL);
+	if (EG(exception)) {
+		zval_ptr_dtor(return_value);
+		ZVAL_UNDEF(return_value);
+		RETURN_THROWS();
+	}
+}
+
+static PHP_GINIT_FUNCTION(html)
+{
+	html_globals->component_factories = NULL;
+	html_globals->component_decorators = NULL;
+}
+
+PHP_RSHUTDOWN_FUNCTION(html)
+{
+	/* Component hooks are request-scoped; drop the ones registered this request. */
+	if (HTML_G(component_factories) != NULL) {
+		zend_hash_release(HTML_G(component_factories));
+		HTML_G(component_factories) = NULL;
+	}
+	if (HTML_G(component_decorators) != NULL) {
+		zend_hash_release(HTML_G(component_decorators));
+		HTML_G(component_decorators) = NULL;
+	}
+	return SUCCESS;
+}
+
+PHP_MINIT_FUNCTION(html)
+{
+	html_ce_Htmlable = register_class_Html_Htmlable(zend_ce_stringable);
+	html_ce_Htmlable->interface_gets_implemented = html_implement_htmlable;
+	html_str_tostring = zend_string_init_interned(ZEND_STRL("__toString"), true);
+	html_str_tostring_lc = zend_string_init_interned(ZEND_STRL("__tostring"), true);
+	for (size_t i = 0; i < sizeof(html_zarginfo_default_tostring) / sizeof(zend_arg_info); i++) {
+		zend_convert_internal_arg_info(&html_zarginfo_default_tostring[i],
+			&arginfo_class_Html_Htmlable___toString[i], i == 0, true);
+	}
+
+	html_ce_Element = register_class_Html_Element(html_ce_Htmlable);
+	html_ce_Fragment = register_class_Html_Fragment(html_ce_Htmlable);
+	html_ce_Raw = register_class_Html_Raw(html_ce_Htmlable);
+	html_ce_Slot = register_class_Html_Slot();
+
+	html_ce_LazyFragment = register_class_Html_LazyFragment(html_ce_Htmlable);
+	html_ce_LazyFragment->create_object = html_lazy_fragment_create;
+	memcpy(&html_lazy_fragment_handlers, &std_object_handlers, sizeof(zend_object_handlers));
+	html_lazy_fragment_handlers.offset = offsetof(html_lazy_fragment, std);
+	html_lazy_fragment_handlers.free_obj = html_lazy_fragment_free;
+	html_lazy_fragment_handlers.get_gc = html_lazy_fragment_get_gc;
+	html_lazy_fragment_handlers.clone_obj = NULL;
+
+	/* The parser lowers markup to these fully-qualified names (zend_markup.h);
+	 * assert the runtime registers exactly them so the two can never drift. */
+	ZEND_ASSERT(zend_string_equals_literal(html_ce_Element->name, ZEND_MARKUP_ELEMENT_FQ));
+	ZEND_ASSERT(zend_string_equals_literal(html_ce_Fragment->name, ZEND_MARKUP_FRAGMENT_FQ));
+	ZEND_ASSERT(zend_string_equals_literal(html_ce_LazyFragment->name, ZEND_MARKUP_LAZY_FRAGMENT_FQ));
+
+	return SUCCESS;
+}
+
+PHP_MINFO_FUNCTION(html)
+{
+	php_info_print_table_start();
+	php_info_print_table_row(2, "html support", "enabled");
+	php_info_print_table_end();
+}
+
+zend_module_entry html_module_entry = {
+	STANDARD_MODULE_HEADER,
+	"html",					/* Extension name */
+	ext_functions,			/* zend_function_entry */
+	PHP_MINIT(html),		/* PHP_MINIT - Module initialization */
+	NULL,					/* PHP_MSHUTDOWN - Module shutdown */
+	NULL,					/* PHP_RINIT - Request initialization */
+	PHP_RSHUTDOWN(html),	/* PHP_RSHUTDOWN - Request shutdown */
+	PHP_MINFO(html),		/* PHP_MINFO - Module info */
+	PHP_HTML_VERSION,		/* Version */
+	PHP_MODULE_GLOBALS(html),	/* Module globals */
+	PHP_GINIT(html),		/* PHP_GINIT - Global initialization */
+	NULL,					/* PHP_GSHUTDOWN - Global shutdown */
+	NULL,					/* Post deactivate */
+	STANDARD_MODULE_PROPERTIES_EX,
+};
+
+#ifdef COMPILE_DL_HTML
+ZEND_GET_MODULE(html)
+#endif
diff --git a/ext/html/html.stub.php b/ext/html/html.stub.php
new file mode 100644
index 000000000000..61bfb8adcf19
--- /dev/null
+++ b/ext/html/html.stub.php
@@ -0,0 +1,250 @@
+<?php
+
+/** @generate-class-entries */
+
+namespace Html {
+
+    require "Zend/zend_attributes.stub.php";
+
+    interface Htmlable extends \Stringable
+    {
+        /**
+         * Produces the markup this value renders as: ultimately an
+         * Html\Element, Html\Fragment, or Html\Raw, though returning any
+         * other Htmlable (e.g. another component instance) is allowed and
+         * is resolved recursively at render time.
+         */
+        public function toHtml(): \Html\Htmlable;
+
+        /**
+         * Renders the value to a safely-escaped HTML string. A userland
+         * class implementing Htmlable that does not declare (or inherit) a
+         * __toString() of its own receives a default implementation - which
+         * serializes what toHtml() produces - at class-link time, the way
+         * enums receive cases(). Only toHtml() must be written by hand.
+         */
+        public function __toString(): string;
+    }
+
+    /**
+     * A single HTML element: a tag, a string-keyed attribute map, and an
+     * ordered list of children. Renders to escape-by-default HTML.
+     *
+     * @strict-properties
+     */
+    final class Element implements \Html\Htmlable
+    {
+        public readonly string $tag;
+        public readonly array $attributes;
+        public readonly array $children;
+
+        public function __construct(string $tag, array $attributes = [], array $children = []) {}
+
+        /** This element itself: the node classes are the base cases of toHtml() resolution. */
+        public function toHtml(): \Html\Htmlable {}
+
+        public function __toString(): string {}
+    }
+
+    /**
+     * An ordered list of children with no wrapping element. Produced by `<>…</>`.
+     *
+     * @strict-properties
+     */
+    final class Fragment implements \Html\Htmlable
+    {
+        public readonly array $children;
+
+        public function __construct(array $children = []) {}
+
+        /** This fragment itself: the node classes are the base cases of toHtml() resolution. */
+        public function toHtml(): \Html\Htmlable {}
+
+        public function __toString(): string {}
+    }
+
+    /**
+     * Opaque, already-safe HTML. Passes through serialization un-escaped.
+     * Backs both `Html\raw()` and `Html\escape()`.
+     *
+     * @strict-properties
+     */
+    final class Raw implements \Html\Htmlable
+    {
+        public readonly string $html;
+
+        public function __construct(string $html) {}
+
+        /** This raw chunk itself: the node classes are the base cases of toHtml() resolution. */
+        public function toHtml(): \Html\Htmlable {}
+
+        public function __toString(): string {}
+    }
+
+    /**
+     * Marks the component parameter that receives the component's body content
+     * (the slot). At most one parameter per component may carry it. Content for
+     * additional "slots" is passed as ordinary props whose type is Html\Htmlable
+     * (e.g. `<Layout header={<h1>Title</h1>}>…</Layout>`).
+     */
+    #[\Attribute(\Attribute::TARGET_PARAMETER)]
+    final class Slot {}
+
+    /**
+     * A slot body whose evaluation is deferred: it builds the child subtree -
+     * and runs any side effects in its interpolations - only the first time it
+     * is rendered, memoizing the result. Produced by the `:lazy` directive on a
+     * component tag (`<Auth :lazy>…</Auth>`), so a component that discards its
+     * body never evaluates it. Because it is itself an Html\Htmlable, a
+     * component's slot parameter type is unchanged (`?Html\Htmlable`); laziness
+     * is transparent to the component.
+     *
+     * @strict-properties
+     */
+    final class LazyFragment implements \Html\Htmlable
+    {
+        /** The thunk builds the deferred body and is called at most once. */
+        public function __construct(\Closure $thunk) {}
+
+        /** Evaluates the thunk on first call (memoized) and returns its Html\Htmlable. */
+        public function toHtml(): \Html\Htmlable {}
+
+        public function __toString(): string {}
+    }
+
+    /**
+     * Wraps a trusted string as already-safe HTML. The explicit, greppable
+     * opt-out of escape-by-default.
+     */
+    function raw(string $html): \Html\Htmlable {}
+
+    /**
+     * Escapes a string and returns it as already-safe HTML, so it passes
+     * through later serialization without being escaped a second time.
+     */
+    function escape(string $text): \Html\Htmlable {}
+
+    /**
+     * Dispatches a component and returns the Html\Htmlable it
+     * produces. This is the runtime target a `<Component …/>` markup tag lowers
+     * into; it is exposed as a public function so the dispatch and slot-routing
+     * rules are directly testable, but user code is expected to write tags.
+     *
+     * A component is a class implementing Html\Htmlable, or a public static
+     * method on a class ("Class::method"). $component is the already-resolved
+     * name (the compiler resolves the tag - the class part of a "::" tag
+     * included - against `use` imports and the current namespace, as
+     * `Component::class` does). A class name is looked up, confirmed to
+     * implement Html\Htmlable, and instantiated; a "Class::method" name is
+     * called and must return an Html\Htmlable. Anything else - no such class,
+     * a class not implementing the interface, a non-public/non-static method -
+     * is a hard error. Plain functions are not components (Future Scope).
+     *
+     * $props become named arguments. The body $slot is routed to the parameter
+     * marked with #[Html\Slot]. A parameter filled by both a prop and the body,
+     * more than one #[Html\Slot] parameter, or body content with no #[Html\Slot]
+     * parameter are all errors.
+     *
+     * @param array<string, mixed> $props
+     */
+    function render_component(
+        string $component,
+        array $props = [],
+        ?\Html\Htmlable $slot = null,
+    ): \Html\Htmlable {}
+
+    /**
+     * Renders a dynamic tag: the runtime target a `<$tag …>…</$tag>`
+     * or `<{expr} …>…</>` markup tag lowers into. $tag's value decides at runtime exactly what a
+     * static tag name decides at compile time, by the same classification
+     * rule: a name with an uppercase first character, a "\", or a "::"
+     * dispatches as a component (so `$tag = Card::class` behaves like
+     * `<Card/>`, hooks and decorators included, with $attributes as props and
+     * $children as the body slot); anything else constructs a literal
+     * `new \Html\Element($tag, $attributes, $children)` (so `$tag = 'div'`
+     * behaves like `<div>`). There is no compile-time `use` resolution, so pass
+     * a fully-qualified name (Foo::class).
+     *
+     * @param array<string, mixed> $attributes
+     * @param array<int, mixed> $children
+     */
+    function render_dynamic(
+        string $tag,
+        array $attributes = [],
+        array $children = [],
+    ): \Html\Htmlable {}
+
+    /**
+     * Register a factory that instantiates *class* components (`<Card/>`), so a
+     * framework can resolve them through its container instead of a bare `new`.
+     * The engine still resolves the name, confirms the class implements
+     * Html\Htmlable, and routes props + #[Html\Slot] content into named arguments;
+     * the factory only replaces construction.
+     *
+     * The factory is called as `$factory(string $class, array $args): ?object`
+     * with the resolved class name and the routed named-argument array (the same
+     * array the constructor would receive). It must return either an instance of
+     * $class (which the engine then uses) or null to defer to the next registered
+     * factory (and finally the engine's own `new`). Factories are tried in
+     * registration order. Registration is request-scoped.
+     *
+     * Passing $component (a class FQCN; case-insensitive, with or without a
+     * leading backslash) scopes the factory to that one component: it only runs
+     * when the resolved class name matches, and every other class component
+     * skips it entirely - no userland call is made. Scoped and unscoped
+     * factories share one chain, still tried in registration order.
+     *
+     * Example (Laravel):
+     *   Html\register_component_factory(
+     *       fn(string $class, array $args) => app()->make($class, $args)
+     *   );
+     *
+     * Example (one component only):
+     *   Html\register_component_factory(
+     *       fn(string $class, array $args) => new Card(...$args, theme: $theme),
+     *       Card::class
+     *   );
+     */
+    function register_component_factory(callable $factory, ?string $component = null): void {}
+
+    /**
+     * Remove a previously registered component factory. Returns whether one
+     * matched. The registration to remove is identified by both the callable
+     * and the $component scope it was registered with (null only matches an
+     * unscoped registration).
+     */
+    function unregister_component_factory(callable $factory, ?string $component = null): bool {}
+
+    /**
+     * Register a decorator that runs on the Html\Htmlable every component
+     * produces - class and static-method alike - after it has been constructed
+     * or called. This is the cross-cutting seam (as opposed to the factory
+     * production seam): use it to wrap, transform, log, profile, or cache
+     * component output uniformly.
+     *
+     * The decorator is called as
+     * `$decorator(Html\Htmlable $rendered, string $component): Html\Htmlable`
+     * with the produced value and the resolved component name, and must return an
+     * Html\Htmlable. Decorators compose in registration order, each receiving the
+     * previous one's result. Registration is request-scoped.
+     *
+     * Passing $component scopes the decorator to that one component: it only
+     * runs when the resolved component name - the same name the decorator
+     * receives - matches (case-insensitive, with or without a leading
+     * backslash). Every other component skips it entirely.
+     *
+     * Example: uppercase every component's output.
+     *   Html\register_component_decorator(
+     *       fn(Html\Htmlable $h, string $c) => Html\raw(strtoupper((string) $h))
+     *   );
+     */
+    function register_component_decorator(callable $decorator, ?string $component = null): void {}
+
+    /**
+     * Remove a previously registered component decorator. Returns whether one
+     * matched. The registration to remove is identified by both the callable
+     * and the $component scope it was registered with (null only matches an
+     * unscoped registration).
+     */
+    function unregister_component_decorator(callable $decorator, ?string $component = null): bool {}
+}
diff --git a/ext/html/html_arginfo.h b/ext/html/html_arginfo.h
new file mode 100644
index 000000000000..8b6d1ee5f490
--- /dev/null
+++ b/ext/html/html_arginfo.h
@@ -0,0 +1,249 @@
+/* This is a generated file, edit html.stub.php instead.
+ * Stub hash: eaef41e6bb5861baded549bcdab72debb58206f6 */
+
+ZEND_BEGIN_ARG_WITH_RETURN_OBJ_INFO_EX(arginfo_Html_raw, 0, 1, Html\\Htmlable, 0)
+	ZEND_ARG_TYPE_INFO(0, html, IS_STRING, 0)
+ZEND_END_ARG_INFO()
+
+ZEND_BEGIN_ARG_WITH_RETURN_OBJ_INFO_EX(arginfo_Html_escape, 0, 1, Html\\Htmlable, 0)
+	ZEND_ARG_TYPE_INFO(0, text, IS_STRING, 0)
+ZEND_END_ARG_INFO()
+
+ZEND_BEGIN_ARG_WITH_RETURN_OBJ_INFO_EX(arginfo_Html_render_component, 0, 1, Html\\Htmlable, 0)
+	ZEND_ARG_TYPE_INFO(0, component, IS_STRING, 0)
+	ZEND_ARG_TYPE_INFO_WITH_DEFAULT_VALUE(0, props, IS_ARRAY, 0, "[]")
+	ZEND_ARG_OBJ_INFO_WITH_DEFAULT_VALUE(0, slot, Html\\Htmlable, 1, "null")
+ZEND_END_ARG_INFO()
+
+ZEND_BEGIN_ARG_WITH_RETURN_OBJ_INFO_EX(arginfo_Html_render_dynamic, 0, 1, Html\\Htmlable, 0)
+	ZEND_ARG_TYPE_INFO(0, tag, IS_STRING, 0)
+	ZEND_ARG_TYPE_INFO_WITH_DEFAULT_VALUE(0, attributes, IS_ARRAY, 0, "[]")
+	ZEND_ARG_TYPE_INFO_WITH_DEFAULT_VALUE(0, children, IS_ARRAY, 0, "[]")
+ZEND_END_ARG_INFO()
+
+ZEND_BEGIN_ARG_WITH_RETURN_TYPE_INFO_EX(arginfo_Html_register_component_factory, 0, 1, IS_VOID, 0)
+	ZEND_ARG_TYPE_INFO(0, factory, IS_CALLABLE, 0)
+	ZEND_ARG_TYPE_INFO_WITH_DEFAULT_VALUE(0, component, IS_STRING, 1, "null")
+ZEND_END_ARG_INFO()
+
+ZEND_BEGIN_ARG_WITH_RETURN_TYPE_INFO_EX(arginfo_Html_unregister_component_factory, 0, 1, _IS_BOOL, 0)
+	ZEND_ARG_TYPE_INFO(0, factory, IS_CALLABLE, 0)
+	ZEND_ARG_TYPE_INFO_WITH_DEFAULT_VALUE(0, component, IS_STRING, 1, "null")
+ZEND_END_ARG_INFO()
+
+ZEND_BEGIN_ARG_WITH_RETURN_TYPE_INFO_EX(arginfo_Html_register_component_decorator, 0, 1, IS_VOID, 0)
+	ZEND_ARG_TYPE_INFO(0, decorator, IS_CALLABLE, 0)
+	ZEND_ARG_TYPE_INFO_WITH_DEFAULT_VALUE(0, component, IS_STRING, 1, "null")
+ZEND_END_ARG_INFO()
+
+ZEND_BEGIN_ARG_WITH_RETURN_TYPE_INFO_EX(arginfo_Html_unregister_component_decorator, 0, 1, _IS_BOOL, 0)
+	ZEND_ARG_TYPE_INFO(0, decorator, IS_CALLABLE, 0)
+	ZEND_ARG_TYPE_INFO_WITH_DEFAULT_VALUE(0, component, IS_STRING, 1, "null")
+ZEND_END_ARG_INFO()
+
+ZEND_BEGIN_ARG_WITH_RETURN_OBJ_INFO_EX(arginfo_class_Html_Htmlable_toHtml, 0, 0, Html\\Htmlable, 0)
+ZEND_END_ARG_INFO()
+
+ZEND_BEGIN_ARG_WITH_RETURN_TYPE_INFO_EX(arginfo_class_Html_Htmlable___toString, 0, 0, IS_STRING, 0)
+ZEND_END_ARG_INFO()
+
+ZEND_BEGIN_ARG_INFO_EX(arginfo_class_Html_Element___construct, 0, 0, 1)
+	ZEND_ARG_TYPE_INFO(0, tag, IS_STRING, 0)
+	ZEND_ARG_TYPE_INFO_WITH_DEFAULT_VALUE(0, attributes, IS_ARRAY, 0, "[]")
+	ZEND_ARG_TYPE_INFO_WITH_DEFAULT_VALUE(0, children, IS_ARRAY, 0, "[]")
+ZEND_END_ARG_INFO()
+
+#define arginfo_class_Html_Element_toHtml arginfo_class_Html_Htmlable_toHtml
+
+#define arginfo_class_Html_Element___toString arginfo_class_Html_Htmlable___toString
+
+ZEND_BEGIN_ARG_INFO_EX(arginfo_class_Html_Fragment___construct, 0, 0, 0)
+	ZEND_ARG_TYPE_INFO_WITH_DEFAULT_VALUE(0, children, IS_ARRAY, 0, "[]")
+ZEND_END_ARG_INFO()
+
+#define arginfo_class_Html_Fragment_toHtml arginfo_class_Html_Htmlable_toHtml
+
+#define arginfo_class_Html_Fragment___toString arginfo_class_Html_Htmlable___toString
+
+ZEND_BEGIN_ARG_INFO_EX(arginfo_class_Html_Raw___construct, 0, 0, 1)
+	ZEND_ARG_TYPE_INFO(0, html, IS_STRING, 0)
+ZEND_END_ARG_INFO()
+
+#define arginfo_class_Html_Raw_toHtml arginfo_class_Html_Htmlable_toHtml
+
+#define arginfo_class_Html_Raw___toString arginfo_class_Html_Htmlable___toString
+
+ZEND_BEGIN_ARG_INFO_EX(arginfo_class_Html_LazyFragment___construct, 0, 0, 1)
+	ZEND_ARG_OBJ_INFO(0, thunk, Closure, 0)
+ZEND_END_ARG_INFO()
+
+#define arginfo_class_Html_LazyFragment_toHtml arginfo_class_Html_Htmlable_toHtml
+
+#define arginfo_class_Html_LazyFragment___toString arginfo_class_Html_Htmlable___toString
+
+ZEND_FUNCTION(Html_raw);
+ZEND_FUNCTION(Html_escape);
+ZEND_FUNCTION(Html_render_component);
+ZEND_FUNCTION(Html_render_dynamic);
+ZEND_FUNCTION(Html_register_component_factory);
+ZEND_FUNCTION(Html_unregister_component_factory);
+ZEND_FUNCTION(Html_register_component_decorator);
+ZEND_FUNCTION(Html_unregister_component_decorator);
+ZEND_METHOD(Html_Element, __construct);
+ZEND_METHOD(Html_Element, toHtml);
+ZEND_METHOD(Html_Element, __toString);
+ZEND_METHOD(Html_Fragment, __construct);
+ZEND_METHOD(Html_Fragment, toHtml);
+ZEND_METHOD(Html_Fragment, __toString);
+ZEND_METHOD(Html_Raw, __construct);
+ZEND_METHOD(Html_Raw, toHtml);
+ZEND_METHOD(Html_Raw, __toString);
+ZEND_METHOD(Html_LazyFragment, __construct);
+ZEND_METHOD(Html_LazyFragment, toHtml);
+ZEND_METHOD(Html_LazyFragment, __toString);
+
+static const zend_function_entry ext_functions[] = {
+	ZEND_RAW_FENTRY(ZEND_NS_NAME("Html", "raw"), zif_Html_raw, arginfo_Html_raw, 0, NULL, NULL)
+	ZEND_RAW_FENTRY(ZEND_NS_NAME("Html", "escape"), zif_Html_escape, arginfo_Html_escape, 0, NULL, NULL)
+	ZEND_RAW_FENTRY(ZEND_NS_NAME("Html", "render_component"), zif_Html_render_component, arginfo_Html_render_component, 0, NULL, NULL)
+	ZEND_RAW_FENTRY(ZEND_NS_NAME("Html", "render_dynamic"), zif_Html_render_dynamic, arginfo_Html_render_dynamic, 0, NULL, NULL)
+	ZEND_RAW_FENTRY(ZEND_NS_NAME("Html", "register_component_factory"), zif_Html_register_component_factory, arginfo_Html_register_component_factory, 0, NULL, NULL)
+	ZEND_RAW_FENTRY(ZEND_NS_NAME("Html", "unregister_component_factory"), zif_Html_unregister_component_factory, arginfo_Html_unregister_component_factory, 0, NULL, NULL)
+	ZEND_RAW_FENTRY(ZEND_NS_NAME("Html", "register_component_decorator"), zif_Html_register_component_decorator, arginfo_Html_register_component_decorator, 0, NULL, NULL)
+	ZEND_RAW_FENTRY(ZEND_NS_NAME("Html", "unregister_component_decorator"), zif_Html_unregister_component_decorator, arginfo_Html_unregister_component_decorator, 0, NULL, NULL)
+	ZEND_FE_END
+};
+
+static const zend_function_entry class_Html_Htmlable_methods[] = {
+	ZEND_RAW_FENTRY("toHtml", NULL, arginfo_class_Html_Htmlable_toHtml, ZEND_ACC_PUBLIC|ZEND_ACC_ABSTRACT, NULL, NULL)
+	ZEND_RAW_FENTRY("__toString", NULL, arginfo_class_Html_Htmlable___toString, ZEND_ACC_PUBLIC|ZEND_ACC_ABSTRACT, NULL, NULL)
+	ZEND_FE_END
+};
+
+static const zend_function_entry class_Html_Element_methods[] = {
+	ZEND_ME(Html_Element, __construct, arginfo_class_Html_Element___construct, ZEND_ACC_PUBLIC)
+	ZEND_ME(Html_Element, toHtml, arginfo_class_Html_Element_toHtml, ZEND_ACC_PUBLIC)
+	ZEND_ME(Html_Element, __toString, arginfo_class_Html_Element___toString, ZEND_ACC_PUBLIC)
+	ZEND_FE_END
+};
+
+static const zend_function_entry class_Html_Fragment_methods[] = {
+	ZEND_ME(Html_Fragment, __construct, arginfo_class_Html_Fragment___construct, ZEND_ACC_PUBLIC)
+	ZEND_ME(Html_Fragment, toHtml, arginfo_class_Html_Fragment_toHtml, ZEND_ACC_PUBLIC)
+	ZEND_ME(Html_Fragment, __toString, arginfo_class_Html_Fragment___toString, ZEND_ACC_PUBLIC)
+	ZEND_FE_END
+};
+
+static const zend_function_entry class_Html_Raw_methods[] = {
+	ZEND_ME(Html_Raw, __construct, arginfo_class_Html_Raw___construct, ZEND_ACC_PUBLIC)
+	ZEND_ME(Html_Raw, toHtml, arginfo_class_Html_Raw_toHtml, ZEND_ACC_PUBLIC)
+	ZEND_ME(Html_Raw, __toString, arginfo_class_Html_Raw___toString, ZEND_ACC_PUBLIC)
+	ZEND_FE_END
+};
+
+static const zend_function_entry class_Html_LazyFragment_methods[] = {
+	ZEND_ME(Html_LazyFragment, __construct, arginfo_class_Html_LazyFragment___construct, ZEND_ACC_PUBLIC)
+	ZEND_ME(Html_LazyFragment, toHtml, arginfo_class_Html_LazyFragment_toHtml, ZEND_ACC_PUBLIC)
+	ZEND_ME(Html_LazyFragment, __toString, arginfo_class_Html_LazyFragment___toString, ZEND_ACC_PUBLIC)
+	ZEND_FE_END
+};
+
+static zend_class_entry *register_class_Html_Htmlable(zend_class_entry *class_entry_Stringable)
+{
+	zend_class_entry ce, *class_entry;
+
+	INIT_NS_CLASS_ENTRY(ce, "Html", "Htmlable", class_Html_Htmlable_methods);
+	class_entry = zend_register_internal_interface(&ce);
+	zend_class_implements(class_entry, 1, class_entry_Stringable);
+
+	return class_entry;
+}
+
+static zend_class_entry *register_class_Html_Element(zend_class_entry *class_entry_Html_Htmlable)
+{
+	zend_class_entry ce, *class_entry;
+
+	INIT_NS_CLASS_ENTRY(ce, "Html", "Element", class_Html_Element_methods);
+	class_entry = zend_register_internal_class_with_flags(&ce, NULL, ZEND_ACC_FINAL|ZEND_ACC_NO_DYNAMIC_PROPERTIES);
+	zend_class_implements(class_entry, 1, class_entry_Html_Htmlable);
+
+	zval property_tag_default_value;
+	ZVAL_UNDEF(&property_tag_default_value);
+	zend_string *property_tag_name = zend_string_init("tag", sizeof("tag") - 1, true);
+	zend_declare_typed_property(class_entry, property_tag_name, &property_tag_default_value, ZEND_ACC_PUBLIC|ZEND_ACC_READONLY, NULL, (zend_type) ZEND_TYPE_INIT_MASK(MAY_BE_STRING));
+	zend_string_release_ex(property_tag_name, true);
+
+	zval property_attributes_default_value;
+	ZVAL_UNDEF(&property_attributes_default_value);
+	zend_string *property_attributes_name = zend_string_init("attributes", sizeof("attributes") - 1, true);
+	zend_declare_typed_property(class_entry, property_attributes_name, &property_attributes_default_value, ZEND_ACC_PUBLIC|ZEND_ACC_READONLY, NULL, (zend_type) ZEND_TYPE_INIT_MASK(MAY_BE_ARRAY));
+	zend_string_release_ex(property_attributes_name, true);
+
+	zval property_children_default_value;
+	ZVAL_UNDEF(&property_children_default_value);
+	zend_string *property_children_name = zend_string_init("children", sizeof("children") - 1, true);
+	zend_declare_typed_property(class_entry, property_children_name, &property_children_default_value, ZEND_ACC_PUBLIC|ZEND_ACC_READONLY, NULL, (zend_type) ZEND_TYPE_INIT_MASK(MAY_BE_ARRAY));
+	zend_string_release_ex(property_children_name, true);
+
+	return class_entry;
+}
+
+static zend_class_entry *register_class_Html_Fragment(zend_class_entry *class_entry_Html_Htmlable)
+{
+	zend_class_entry ce, *class_entry;
+
+	INIT_NS_CLASS_ENTRY(ce, "Html", "Fragment", class_Html_Fragment_methods);
+	class_entry = zend_register_internal_class_with_flags(&ce, NULL, ZEND_ACC_FINAL|ZEND_ACC_NO_DYNAMIC_PROPERTIES);
+	zend_class_implements(class_entry, 1, class_entry_Html_Htmlable);
+
+	zval property_children_default_value;
+	ZVAL_UNDEF(&property_children_default_value);
+	zend_string *property_children_name = zend_string_init("children", sizeof("children") - 1, true);
+	zend_declare_typed_property(class_entry, property_children_name, &property_children_default_value, ZEND_ACC_PUBLIC|ZEND_ACC_READONLY, NULL, (zend_type) ZEND_TYPE_INIT_MASK(MAY_BE_ARRAY));
+	zend_string_release_ex(property_children_name, true);
+
+	return class_entry;
+}
+
+static zend_class_entry *register_class_Html_Raw(zend_class_entry *class_entry_Html_Htmlable)
+{
+	zend_class_entry ce, *class_entry;
+
+	INIT_NS_CLASS_ENTRY(ce, "Html", "Raw", class_Html_Raw_methods);
+	class_entry = zend_register_internal_class_with_flags(&ce, NULL, ZEND_ACC_FINAL|ZEND_ACC_NO_DYNAMIC_PROPERTIES);
+	zend_class_implements(class_entry, 1, class_entry_Html_Htmlable);
+
+	zval property_html_default_value;
+	ZVAL_UNDEF(&property_html_default_value);
+	zend_string *property_html_name = zend_string_init("html", sizeof("html") - 1, true);
+	zend_declare_typed_property(class_entry, property_html_name, &property_html_default_value, ZEND_ACC_PUBLIC|ZEND_ACC_READONLY, NULL, (zend_type) ZEND_TYPE_INIT_MASK(MAY_BE_STRING));
+	zend_string_release_ex(property_html_name, true);
+
+	return class_entry;
+}
+
+static zend_class_entry *register_class_Html_Slot(void)
+{
+	zend_class_entry ce, *class_entry;
+
+	INIT_NS_CLASS_ENTRY(ce, "Html", "Slot", NULL);
+	class_entry = zend_register_internal_class_with_flags(&ce, NULL, ZEND_ACC_FINAL);
+
+	zend_string *attribute_name_Attribute_class_Html_Slot_0 = zend_string_init_interned("Attribute", sizeof("Attribute") - 1, true);
+	zend_attribute *attribute_Attribute_class_Html_Slot_0 = zend_add_class_attribute(class_entry, attribute_name_Attribute_class_Html_Slot_0, 1);
+	zend_string_release_ex(attribute_name_Attribute_class_Html_Slot_0, true);
+	ZVAL_LONG(&attribute_Attribute_class_Html_Slot_0->args[0].value, ZEND_ATTRIBUTE_TARGET_PARAMETER);
+
+	return class_entry;
+}
+
+static zend_class_entry *register_class_Html_LazyFragment(zend_class_entry *class_entry_Html_Htmlable)
+{
+	zend_class_entry ce, *class_entry;
+
+	INIT_NS_CLASS_ENTRY(ce, "Html", "LazyFragment", class_Html_LazyFragment_methods);
+	class_entry = zend_register_internal_class_with_flags(&ce, NULL, ZEND_ACC_FINAL|ZEND_ACC_NO_DYNAMIC_PROPERTIES);
+	zend_class_implements(class_entry, 1, class_entry_Html_Htmlable);
+
+	return class_entry;
+}
diff --git a/ext/html/php_html.h b/ext/html/php_html.h
new file mode 100644
index 000000000000..9bb40aff0f1b
--- /dev/null
+++ b/ext/html/php_html.h
@@ -0,0 +1,48 @@
+/*
+   +----------------------------------------------------------------------+
+   | Copyright © The PHP Group and Contributors.                          |
+   +----------------------------------------------------------------------+
+   | This source file is subject to the Modified BSD License that is      |
+   | bundled with this package in the file LICENSE, and is available      |
+   | through the world-wide-web at the following url:                     |
+   | https://www.php.net/license/3_01.txt                                 |
+   | If you did not receive a copy of the PHP license and are unable to   |
+   | obtain it through the world-wide-web, please send a note to          |
+   | license@php.net so we can mail you a copy immediately.               |
+   +----------------------------------------------------------------------+
+   | Author: Liam Hammett                                                 |
+   +----------------------------------------------------------------------+
+*/
+
+#ifndef PHP_HTML_EXT_H
+#define PHP_HTML_EXT_H
+
+#include "php.h"
+
+extern zend_module_entry html_module_entry;
+#define phpext_html_ptr &html_module_entry
+
+#define PHP_HTML_VERSION PHP_VERSION
+
+/* Request-scoped userland hooks that let a framework take over how a component
+ * tag is turned into an object. `component_factories` replace the `new`
+ * for a component (e.g. resolve through a DI container) - the *production* seam.
+ * `component_decorators` are the cross-cutting seam: they run on the produced
+ * Html\Htmlable of every component, so output transforms / wrapping / logging
+ * apply uniformly. Each is an ordered list of html_handler entries (callable +
+ * optional per-component scope) tried in registration order, like
+ * spl_autoload_register; a factory returns an object to take over the dispatch
+ * or null to defer, while each decorator wraps the previous one's result. A
+ * scoped entry is skipped in C - before any userland call - for every other
+ * component. Both are NULL until first registered and are cleared at request
+ * shutdown. */
+ZEND_BEGIN_MODULE_GLOBALS(html)
+	HashTable *component_factories;
+	HashTable *component_decorators;
+ZEND_END_MODULE_GLOBALS(html)
+
+ZEND_EXTERN_MODULE_GLOBALS(html)
+
+#define HTML_G(v) ZEND_MODULE_GLOBALS_ACCESSOR(html, v)
+
+#endif /* PHP_HTML_EXT_H */
diff --git a/ext/html/tests/children.phpt b/ext/html/tests/children.phpt
new file mode 100644
index 000000000000..161f5963636a
--- /dev/null
+++ b/ext/html/tests/children.phpt
@@ -0,0 +1,94 @@
+--TEST--
+Html\Element children: scalar coercion, recursive array flattening, Traversables, and the nesting-depth bound
+--EXTENSIONS--
+html
+--FILE--
+<?php
+use Html\Element;
+use Html\Element as E;
+use function Html\raw;
+
+// --- scalar and array child coercion ---
+
+// Scalars: int/float stringify, true -> "1", false/null -> "".
+echo (new Element('p', [], [1, ' ', 2.5, ' ', true, false, null]))->__toString(), "\n";
+
+// Arrays flatten recursively (the array_map loop idiom).
+$items = ['Ada', 'Linus', 'Grace'];
+echo (new Element('ul', [], [
+    array_map(fn($n) => new Element('li', [], [$n]), $items),
+]))->__toString(), "\n";
+
+// A nested Htmlable passes through un-escaped.
+echo (new Element('div', [], [raw('<b>bold</b>')]))->__toString(), "\n";
+
+// Nested elements are Htmlable too.
+echo (new Element('div', [], [new Element('em', [], ['hi & bye'])]))->__toString(), "\n";
+
+// Non-Stringable object is a hard error.
+try {
+    (new Element('div', [], [new stdClass]))->__toString();
+} catch (\Throwable $e) {
+    echo get_class($e), ': ', $e->getMessage(), "\n";
+}
+
+// --- Traversable children: generators, Iterator, IteratorAggregate ---
+
+// Generator
+function rows(): Generator {
+    yield new Element('li', [], ['one']);
+    yield new Element('li', [], ['two']);
+}
+echo (new Element('ul', [], [rows()]))->__toString(), "\n";
+
+// ArrayIterator (Iterator), mixing scalars and Htmlable, with keys ignored
+$it = new ArrayIterator(['a' => 'x & y', 'b' => new Element('b', [], ['z'])]);
+echo (new Element('p', [], [$it]))->__toString(), "\n";
+
+// IteratorAggregate, nested inside an array (recursive flattening)
+$agg = new class implements IteratorAggregate {
+    public function getIterator(): Iterator {
+        return new ArrayIterator([new Element('span', [], ['nested'])]);
+    }
+};
+echo (new Element('div', [], [['before ', $agg, ' after']]))->__toString(), "\n";
+
+// An exception thrown mid-iteration propagates.
+function boom(): Generator {
+    yield new Element('i', [], ['ok']);
+    throw new RuntimeException('stop');
+}
+try {
+    (new Element('div', [], [boom()]))->__toString();
+} catch (\Throwable $e) {
+    echo get_class($e), ': ', $e->getMessage(), "\n";
+}
+
+// --- nesting-depth bound ---
+
+// A cheap-to-build, deeply nested array must throw, not crash the process.
+$kids = ['x'];
+for ($i = 0; $i < 100000; $i++) {
+    $kids = [$kids];
+}
+try {
+    echo (new E('div', [], $kids))->__toString(), "\n";
+} catch (\Throwable $e) {
+    echo get_class($e), ': ', $e->getMessage(), "\n";
+}
+
+// Normal (shallow) nesting still renders.
+echo (new E('ul', [], [[[new E('li', [], ['ok'])]]]))->__toString(), "\n";
+?>
+--EXPECTF--
+<p>1 2.5 1</p>
+<ul><li>Ada</li><li>Linus</li><li>Grace</li></ul>
+<div><b>bold</b></div>
+<div><em>hi &amp; bye</em></div>
+TypeError: Object of class stdClass cannot be rendered as a markup child: it implements none of Html\Htmlable, Stringable, or Traversable
+<ul><li>one</li><li>two</li></ul>
+<p>x &amp; y<b>z</b></p>
+<div>before <span>nested</span> after</div>
+RuntimeException: stop
+Error: Maximum markup nesting depth of 1024 exceeded
+<ul><li>ok</li></ul>
diff --git a/ext/html/tests/component_hardening.phpt b/ext/html/tests/component_hardening.phpt
new file mode 100644
index 000000000000..176bfadaa340
--- /dev/null
+++ b/ext/html/tests/component_hardening.phpt
@@ -0,0 +1,109 @@
+--TEST--
+Html components: dispatch guards (visibility, staticness, ctor, void children, hooks) and throwing-constructor safety
+--EXTENSIONS--
+html
+--FILE--
+<?php
+use function Html\render_component;
+
+function expect_error(callable $f): void {
+    try {
+        $f();
+        echo "NO ERROR\n";
+    } catch (Error $e) {
+        echo get_class($e), ": ", $e->getMessage(), "\n";
+    }
+}
+
+// --- hook-registration TypeErrors ---
+
+// Registering a non-callable hook is an immediate TypeError.
+expect_error(fn() => Html\register_component_factory("no_such_function_xyz"));
+expect_error(fn() => Html\register_component_decorator([new stdClass(), "nope"]));
+
+// --- void-element children guard ---
+
+// A void element cannot have children (they would be silently dropped).
+expect_error(fn() => (string) new Html\Element("br", [], ["x"]));
+
+// --- int-keyed props ---
+
+// Integer-keyed props are rejected on every dispatch path.
+class NoAttrs implements Html\Htmlable {
+    public function __construct(public string $a = "") {}
+    public function toHtml(): Html\Htmlable { return Html\raw("no-attrs"); }
+}
+expect_error(fn() => render_component("NoAttrs", ["positional"]));
+
+// --- constructor visibility/absence guards ---
+
+// A non-public constructor cannot be dispatched by the engine.
+class PrivateCtor implements Html\Htmlable {
+    private function __construct() {}
+    public function toHtml(): Html\Htmlable { return Html\raw("private"); }
+}
+expect_error(fn() => render_component("PrivateCtor"));
+
+// A class with no constructor cannot silently swallow props.
+class NoCtor implements Html\Htmlable {
+    public function toHtml(): Html\Htmlable { return Html\raw("no-ctor"); }
+}
+expect_error(fn() => render_component("NoCtor", ["title" => "x"]));
+echo render_component("NoCtor"), "\n"; // without props it is fine
+
+// --- static-method visibility guards ---
+
+// Static-method components must be public, static, and non-abstract.
+class Methods {
+    private static function hidden(): Html\Htmlable { return new Html\Fragment([]); }
+    public function nonStatic(): Html\Htmlable { return new Html\Fragment([]); }
+}
+expect_error(fn() => render_component("Methods::hidden"));
+expect_error(fn() => render_component("Methods::nonStatic"));
+
+// --- throwing constructor: no heap corruption / double free ---
+
+// A component whose constructor cannot be satisfied by the engine's own `new`
+// (a required, non-prop dependency). The thrown error must leave a clean heap:
+// the half-built object is released exactly once, not double-freed.
+class NeedsDep implements Html\Htmlable {
+    public function __construct(private \stdClass $dep) {}
+    public function toHtml(): Html\Htmlable { return Html\raw("never"); }
+}
+
+for ($i = 0; $i < 3; $i++) {
+    try {
+        echo render_component('NeedsDep')->__toString();
+    } catch (\Error $e) {
+        echo $e->getMessage(), "\n";
+    }
+}
+
+// A constructor that throws from its body, too.
+class Boom implements Html\Htmlable {
+    public function __construct() { throw new \RuntimeException("boom"); }
+    public function toHtml(): Html\Htmlable { return Html\raw("never"); }
+}
+try {
+    echo render_component('Boom')->__toString();
+} catch (\Throwable $e) {
+    echo get_class($e), ": ", $e->getMessage(), "\n";
+}
+
+echo "clean\n";
+?>
+--EXPECTF--
+TypeError: Html\register_component_factory(): Argument #1 ($factory) must be a valid callback
+TypeError: Html\register_component_decorator(): Argument #1 ($decorator) must be a valid callback
+Error: Void element <br> cannot have children
+Error: Component props must use string keys
+Error: Component class "PrivateCtor" has a non-public constructor
+Error: Component class "NoCtor" has no constructor, so it cannot accept attributes or slots
+no-ctor
+Error: Component method Methods::hidden() must be a public static user-defined method
+Error: Component method Methods::nonStatic() must be a public static user-defined method
+Too few arguments to function NeedsDep::__construct()%A
+Too few arguments to function NeedsDep::__construct()%A
+Too few arguments to function NeedsDep::__construct()%A
+RuntimeException: boom
+clean
diff --git a/ext/html/tests/component_hooks.phpt b/ext/html/tests/component_hooks.phpt
new file mode 100644
index 000000000000..ffa564db6309
--- /dev/null
+++ b/ext/html/tests/component_hooks.phpt
@@ -0,0 +1,188 @@
+--TEST--
+Html components: factory hooks (DI), decorators, and per-component hook scoping
+--EXTENSIONS--
+html
+--FILE--
+<?php
+use function Html\{register_component_factory, unregister_component_factory,
+    register_component_decorator, unregister_component_decorator};
+
+// Shared components across the sections below.
+class Card implements Html\Htmlable {
+    public function __construct(public string $title = "?") {}
+    public function toHtml(): Html\Htmlable {
+        return new Html\Element('div', [], [$this->title]);
+    }
+}
+class Badge implements Html\Htmlable {
+    public function __construct(public string $label = "?") {}
+    public function toHtml(): Html\Htmlable {
+        return new Html\Element('b', [], [$this->label]);
+    }
+}
+class Note implements Html\Htmlable {
+    public function __construct(public string $t) {}
+    public function toHtml(): Html\Htmlable {
+        return new Html\Element('p', [], [$this->t]);
+    }
+}
+class Author {
+    public static function byline(string $t): Html\Htmlable {
+        return new Html\Element('span', [], [$t]);
+    }
+}
+
+// --- factory hooks: chain, defer, bad return, unregister identity ---
+
+// A dependency the props never supply; the "container" injects it.
+class Clock { public function now(): string { return "T"; } }
+
+// Class component: a DI dependency ($clock) plus a prop ($label).
+class TimeBadge implements Html\Htmlable {
+    public function __construct(private Clock $clock, public string $label) {}
+    public function toHtml(): Html\Htmlable {
+        return new Html\Element('span', [], ["{$this->label}:{$this->clock->now()}"]);
+    }
+}
+
+// A tiny autowiring container: fill non-builtin params the $args don't provide.
+function autowire(ReflectionFunctionAbstract $r, array $args): array {
+    $extra = [];
+    foreach ($r->getParameters() as $p) {
+        $t = $p->getType();
+        if ($t instanceof ReflectionNamedType && !$t->isBuiltin()
+                && !array_key_exists($p->getName(), $args)) {
+            $extra[$p->getName()] = new ($t->getName())();
+        }
+    }
+    return [...$extra, ...$args];
+}
+$defer = fn(string $class, array $args) => null; // always defers to the next factory
+$make = fn(string $class, array $args)
+    => (new ReflectionClass($class))->newInstanceArgs(
+        autowire(new ReflectionMethod($class, '__construct'), $args));
+
+// (1) Without hooks, the engine's own `new` runs and fails for the missing Clock.
+try { echo <TimeBadge label="x"/>; }
+catch (\Error $e) { echo "default:  ", $e->getMessage(), "\n"; }
+
+// $defer is first, so a working result proves the chain skips a null-returning
+// factory and falls through to $make.
+register_component_factory($defer);
+register_component_factory($make);
+
+echo "class:    ", <TimeBadge label="A"/>, "\n";
+
+// (2) A factory must return an instance of the requested class. Swap $make for a
+// bad factory so the chain becomes [$defer, $bad] and the bad one is reached.
+var_dump(unregister_component_factory($make));
+$bad = fn(string $class, array $args) => new Clock();
+register_component_factory($bad);
+try { echo <TimeBadge label="e"/>; }
+catch (\Error $e) { echo "badreturn: ", $e->getMessage(), "\n"; }
+
+// (3) Unregistering everything restores the engine default. Unregister identity
+// is by callable; a fresh closure does not match.
+var_dump(unregister_component_factory(fn($c, $a) => null));
+var_dump(unregister_component_factory($defer));
+var_dump(unregister_component_factory($bad));
+try { echo <TimeBadge label="f"/>; }
+catch (\Error $e) { echo "restored:  ", $e->getMessage(), "\n"; }
+
+// --- decorators: uniform wrapping, composition, bad return ---
+
+// A decorator wrapping in a marker that records the component name; proves it
+// fires for class and static-method components alike, with the resolved name.
+$marker = fn(Html\Htmlable $h, string $c) => Html\raw("[$c]" . $h . "[/$c]");
+register_component_decorator($marker);
+
+echo <Card title="a"/>, "\n";
+echo <Note t="b"/>, "\n";
+echo <Author::byline t="c"/>, "\n";
+
+// Decorators compose in registration order, each wrapping the previous result.
+$outer = fn(Html\Htmlable $h, string $c) => Html\raw("<<" . $h . ">>");
+register_component_decorator($outer);
+echo <Note t="d"/>, "\n";
+
+// A decorator must return an Html\Htmlable.
+$badDecorator = fn(Html\Htmlable $h, string $c) => "not htmlable";
+register_component_decorator($badDecorator);
+try { echo <Note t="e"/>; }
+catch (\Error $e) { echo $e->getMessage(), "\n"; }
+
+// Clean up this section's decorators so the next section starts from default.
+unregister_component_decorator($badDecorator);
+unregister_component_decorator($outer);
+unregister_component_decorator($marker);
+
+// --- per-component scoping of factories and decorators ---
+
+// (1) A factory scoped to Card fires for <Card/> only; <Badge/> keeps the
+// engine default. Scope names are case-insensitive and a leading backslash
+// is accepted.
+$cardFactory = function (string $class, array $args) {
+    echo "factory($class)\n";
+    return new Card("made");
+};
+register_component_factory($cardFactory, '\cArD');
+echo <Card/>, "\n";
+echo <Badge/>, "\n";
+
+// (2) Scoped and unscoped factories share one chain in registration order:
+// the scoped one (registered first) wins for Card; the unscoped one sees Badge.
+$anyFactory = function (string $class, array $args) {
+    echo "any($class)\n";
+    return null; // defer
+};
+register_component_factory($anyFactory);
+echo <Card/>, "\n";
+echo <Badge/>, "\n";
+
+// (3) Unregister identity includes the scope: the callable alone (or with the
+// wrong scope) does not match; with its scope it does.
+var_dump(unregister_component_factory($cardFactory));
+var_dump(unregister_component_factory($cardFactory, 'Badge'));
+var_dump(unregister_component_factory($cardFactory, 'Card'));
+var_dump(unregister_component_factory($anyFactory));
+echo <Card/>, "\n";
+
+// (4) A decorator scoped to Badge wraps only Badge's output - Card renders
+// untouched.
+$badgeDecorator = fn(Html\Htmlable $h, string $c) => Html\raw("<<$h>>");
+register_component_decorator($badgeDecorator, Badge::class);
+echo <Badge label="B"/>, "\n";
+echo <Card title="C"/>, "\n";
+var_dump(unregister_component_decorator($badgeDecorator, 'badge'));
+echo <Badge label="B"/>, "\n";
+?>
+--EXPECT--
+default:  TimeBadge::__construct(): Argument #1 ($clock) not passed
+class:    <span>A:T</span>
+bool(true)
+badreturn: Component factory for <TimeBadge> did not return an instance of it or null
+bool(false)
+bool(true)
+bool(true)
+restored:  TimeBadge::__construct(): Argument #1 ($clock) not passed
+[Card]<div>a</div>[/Card]
+[Note]<p>b</p>[/Note]
+[Author::byline]<span>c</span>[/Author::byline]
+<<[Note]<p>d</p>[/Note]>>
+Component decorator for <Note> did not return an Html\Htmlable
+factory(Card)
+<div>made</div>
+<b>?</b>
+factory(Card)
+<div>made</div>
+any(Badge)
+<b>?</b>
+bool(false)
+bool(false)
+bool(true)
+bool(true)
+<div>?</div>
+<<<b>B</b>>>
+<div>C</div>
+bool(true)
+<b>B</b>
diff --git a/ext/html/tests/component_slots.phpt b/ext/html/tests/component_slots.phpt
new file mode 100644
index 000000000000..745b72d15178
--- /dev/null
+++ b/ext/html/tests/component_slots.phpt
@@ -0,0 +1,116 @@
+--TEST--
+Html components: #[Html\Slot] body routing, slot validation errors, Slot attribute reflection
+--EXTENSIONS--
+html
+--FILE--
+<?php
+use function Html\render_component;
+use Html\Element as E;
+use Html\Fragment;
+use Html\Slot;
+
+function err(callable $fn): string {
+    try { $fn(); return "no error"; }
+    catch (\Throwable $e) { return get_class($e) . ': ' . $e->getMessage(); }
+}
+
+// --- body content routes to the #[Html\Slot] parameter ---
+
+// The body slot routes to the #[Slot] parameter; other content areas are
+// ordinary props typed Html\Htmlable (what named slots used to be).
+class Layout implements Html\Htmlable {
+    public function __construct(
+        public string $lang,
+        #[Slot] public ?Html\Htmlable $body = null,
+        public ?Html\Htmlable $header = null,
+        public ?Html\Htmlable $footer = null,
+    ) {}
+    public function toHtml(): Html\Htmlable {
+        return new E('main', ['lang' => $this->lang], [$this->header, $this->body, $this->footer]);
+    }
+}
+
+$out = render_component(
+    Layout::class,
+    [
+        'lang'   => 'en',
+        'header' => new E('h1', [], ['Title']),
+        'footer' => new Fragment([new E('small', [], ['(c) 2026'])]),
+    ],
+    new Fragment([new E('p', [], ['loose body'])]),          // body slot
+);
+echo $out, "\n";
+
+// Body slot only.
+class Panel implements Html\Htmlable {
+    public function __construct(
+        public string $kind,
+        #[Slot] public ?Html\Htmlable $content = null,
+    ) {}
+    public function toHtml(): Html\Htmlable {
+        return new E('section', ['class' => $this->kind], [$this->content]);
+    }
+}
+echo render_component(Panel::class, ['kind' => 'note'], new Fragment([Html\raw('<b>hi</b>')]))->__toString(), "\n";
+
+// --- slot-routing validation errors ---
+
+// Body content given, but a parameter+attribute would collide.
+class Solo implements Html\Htmlable {
+    public function __construct(#[Slot] public Html\Htmlable $body) {}
+    public function toHtml(): Html\Htmlable { return new E('p', [], [$this->body]); }
+}
+echo err(fn() => render_component(Solo::class, ['body' => 'x'], new Fragment([Html\raw('y')]))), "\n";
+
+// Body content given to a component that has no slot parameter.
+class NoSlot implements Html\Htmlable {
+    public function __construct(public string $x) {}
+    public function toHtml(): Html\Htmlable { return new E('i', [], [$this->x]); }
+}
+echo err(fn() => render_component(NoSlot::class, ['x' => 'hi'], new Fragment([Html\raw('body')]))), "\n";
+
+// More than one slot parameter is a definition error.
+class TwoSlots implements Html\Htmlable {
+    public function __construct(#[Slot] public ?Html\Htmlable $a = null, #[Slot] public ?Html\Htmlable $b = null) {}
+    public function toHtml(): Html\Htmlable { return new Fragment([$this->a, $this->b]); }
+}
+echo err(fn() => render_component(TwoSlots::class, [], new Fragment([]))), "\n";
+
+// #[Slot] on a variadic parameter is a definition error.
+class Variadic implements Html\Htmlable {
+    private array $parts;
+    public function __construct(#[Slot] Html\Htmlable ...$parts) { $this->parts = $parts; }
+    public function toHtml(): Html\Htmlable { return new Fragment($this->parts); }
+}
+echo err(fn() => render_component(Variadic::class, [], new Fragment([]))), "\n";
+
+// --- Html\Slot is a bare parameter-target marker attribute ---
+
+function LayoutFn(
+    #[Slot] Html\Htmlable $body,
+    ?Html\Htmlable $footer = null,
+): Html\Htmlable {
+    return new Html\Fragment([$body, $footer]);
+}
+
+$ref = new ReflectionFunction('LayoutFn');
+foreach ($ref->getParameters() as $param) {
+    foreach ($param->getAttributes(Slot::class) as $attr) {
+        $slot = $attr->newInstance();
+        printf("%s -> %s\n", $param->getName(), get_class($slot));
+    }
+}
+
+// Slot takes no arguments and only targets parameters.
+$attr = (new ReflectionClass(Slot::class))->getAttributes(Attribute::class)[0]->newInstance();
+var_dump($attr->flags === Attribute::TARGET_PARAMETER);
+?>
+--EXPECTF--
+<main lang="en"><h1>Title</h1><p>loose body</p><small>(c) 2026</small></main>
+<section class="note"><b>hi</b></section>
+Error: Parameter $body is filled by both an attribute and body content
+Error: Component received body content but has no #[Html\Slot] parameter
+Error: Component has more than one #[Html\Slot] parameter
+Error: #[Html\Slot] cannot be applied to a variadic parameter
+body -> Html\Slot
+bool(true)
diff --git a/ext/html/tests/components.phpt b/ext/html/tests/components.phpt
new file mode 100644
index 000000000000..a25424d73ff8
--- /dev/null
+++ b/ext/html/tests/components.phpt
@@ -0,0 +1,133 @@
+--TEST--
+Html components: tag lowering, class/static-method dispatch, resolution errors, hyphenated attrs
+--EXTENSIONS--
+html
+--FILE--
+<?php
+use Html\Element as E;
+use Html\Slot;
+use function Html\render_component;
+
+function err(callable $fn): string {
+    try { $fn(); return "no error"; }
+    catch (\Throwable $e) { return get_class($e) . ': ' . $e->getMessage(); }
+}
+
+// --- component tag lowering: class + static-method dispatch ---
+
+// Class component implementing Htmlable, with a prop and an anonymous slot.
+class Card implements Html\Htmlable {
+    public function __construct(
+        public string $title,
+        #[Slot] public ?Html\Htmlable $body = null,
+    ) {}
+    public function toHtml(): Html\Htmlable {
+        return new E('section', ['class' => 'card'], [new E('h2', [], [$this->title]), $this->body]);
+    }
+}
+
+// A second, minimal component for nesting cases.
+class Badge implements Html\Htmlable {
+    public function __construct(public string $label) {}
+    public function toHtml(): Html\Htmlable {
+        return new E('span', ['class' => 'badge'], [$this->label]);
+    }
+}
+
+// Static-method component - multiple components can live together on one class.
+// (broken() returns a non-Htmlable, for the error section below.)
+class Author {
+    public static function byline(string $name): Html\Htmlable {
+        return new E('p', ['class' => 'by'], ['By ', $name]);
+    }
+    public static function broken(): string {
+        return 'plain';
+    }
+}
+
+$who = 'Ada & co';
+
+// class component: attribute prop + body routed to the anonymous slot
+echo (<Card title={$who}><p>Hi {$who}</p></Card>)->__toString(), "\n";
+
+// self-closing class component (no body -> slot is null)
+echo (<Card title="Solo"/>)->__toString(), "\n";
+
+// static-method component
+echo (<Author::byline name={$who}/>)->__toString(), "\n";
+
+// the same dispatch, called directly by name
+echo render_component(Badge::class, ['label' => 'New &'])->__toString(), "\n";
+
+// a component used as a child of an HTML element, and inside interpolation
+echo (<div class="wrap"><Badge label="x"/></div>)->__toString(), "\n";
+echo (<ul>{array_map(fn($t) => <Badge label={$t}/>, ['a', 'b'])}</ul>)->__toString(), "\n";
+
+// --- resolution errors: a component is a class implementing Htmlable ---
+
+// Unknown symbol -> hard error.
+echo err(fn() => render_component('NoSuchThing')), "\n";
+
+// A function name is not a component (functions are Future Scope).
+function Chip(): Html\Htmlable { return Html\raw('FROM FUNCTION'); }
+echo err(fn() => render_component('Chip')), "\n";
+
+// A "date"-named tag can never reach the internal date() function.
+echo err(fn() => render_component('date', ['datetime' => 'now'])), "\n";
+
+// A class that does NOT implement Htmlable -> hard error.
+class Plain {}
+echo err(fn() => render_component('Plain')), "\n";
+
+// "Class::method" resolves to a public static method and is called; the
+// result must be an Html\Htmlable.
+echo render_component('Author::byline', ['name' => 'Ada'])->__toString(), "\n";
+echo err(fn() => render_component('Author::broken')), "\n";
+echo err(fn() => render_component('NoSuchClass::method')), "\n";
+
+// A class implementing Htmlable resolves, regardless of same-named functions.
+function Widget(): Html\Htmlable { return Html\raw('FROM FUNCTION'); }
+class Widget implements Html\Htmlable {
+    public function toHtml(): Html\Htmlable { return Html\raw('FROM CLASS'); }
+}
+echo render_component('Widget')->__toString(), "\n";
+
+// --- hyphenated attributes route through named args ---
+
+// A component that collects arbitrary (incl. hyphenated) attributes via a variadic.
+class Box implements Html\Htmlable {
+    private array $attrs;
+    public function __construct(public string $kind, ...$attrs) { $this->attrs = $attrs; }
+    public function toHtml(): Html\Htmlable {
+        return new E('div', ['class' => $this->kind, ...$this->attrs], ['box']);
+    }
+}
+
+// Hyphenated attributes work directly on a component (no spread needed) - they
+// become named arguments and the variadic collects them.
+echo (<Box kind="note" data-id="7" aria-label="hi"/>), "\n";
+
+// A component without a variadic rejects an unknown (hyphenated) attribute.
+class Tight implements Html\Htmlable {
+    public function __construct(public string $kind) {}
+    public function toHtml(): Html\Htmlable { return new E('div', ['class' => $this->kind], ['y']); }
+}
+echo err(fn() => (<Tight kind="b" data-x="1"/>)->__toString()), "\n";
+?>
+--EXPECT--
+<section class="card"><h2>Ada &amp; co</h2><p>Hi Ada &amp; co</p></section>
+<section class="card"><h2>Solo</h2></section>
+<p class="by">By Ada &amp; co</p>
+<span class="badge">New &amp;</span>
+<div class="wrap"><span class="badge">x</span></div>
+<ul><span class="badge">a</span><span class="badge">b</span></ul>
+Error: "NoSuchThing" is not a component: no such class implementing Html\Htmlable
+Error: "Chip" is not a component: no such class implementing Html\Htmlable
+Error: "date" is not a component: no such class implementing Html\Htmlable
+Error: "Plain" is not a component: no such class implementing Html\Htmlable
+<p class="by">By Ada</p>
+Error: Component "Author::broken" did not return an Html\Htmlable
+Error: Component class "NoSuchClass" not found
+FROM CLASS
+<div class="note" data-id="7" aria-label="hi">box</div>
+Error: Unknown named parameter $data-x
diff --git a/ext/html/tests/element.phpt b/ext/html/tests/element.phpt
new file mode 100644
index 000000000000..a03eb50ac9cb
--- /dev/null
+++ b/ext/html/tests/element.phpt
@@ -0,0 +1,159 @@
+--TEST--
+Html\Element/Fragment/Raw construction API: rendering, escaping, attribute coercion, Htmlable attributes, void elements, raw()/escape(), name validation
+--EXTENSIONS--
+html
+--FILE--
+<?php
+use Html\Element;
+use Html\Element as E;
+use Html\Fragment;
+use function Html\raw;
+use function Html\escape;
+
+// --- basic rendering ---
+
+$el = new Element('a', ['href' => 'https://php.net', 'class' => 'btn'], ['Click me']);
+echo $el->__toString(), "\n";
+echo $el, "\n"; // echo casts via __toString
+
+var_dump($el instanceof Html\Htmlable);
+var_dump($el instanceof Stringable);
+var_dump($el->tag);
+var_dump($el->attributes);
+var_dump($el->children);
+
+// --- escaping ---
+
+// Child text is escaped.
+echo (new Element('p', [], ['Tom & Jerry <3 "quotes" \'apostrophe\'']))->__toString(), "\n";
+
+// Attribute values are escaped.
+echo (new Element('div', ['title' => 'a "b" & <c>'], []))->__toString(), "\n";
+
+// A classic XSS attempt is neutralised.
+$evil = '<script>alert(1)</script>';
+echo (new Element('span', [], [$evil]))->__toString(), "\n";
+
+// --- attribute value coercion ---
+
+// null and false omit the attribute; true is a bare boolean attribute.
+echo (new Element('input', [
+    'type' => 'checkbox',
+    'checked' => true,
+    'disabled' => false,
+    'value' => null,
+    'tabindex' => 3,
+    'data-ratio' => 1.5,
+]))->__toString(), "\n";
+
+// Stringable attribute value.
+$s = new class implements Stringable {
+    public function __toString(): string { return 'x&y'; }
+};
+echo (new Element('a', ['data-x' => $s]))->__toString(), "\n";
+
+// Arrays are reserved -> TypeError.
+try {
+    (new Element('div', ['class' => ['a', 'b']]))->__toString();
+} catch (\Throwable $e) {
+    echo get_class($e), ': ', $e->getMessage(), "\n";
+}
+
+// --- Htmlable attribute values (no double-escaping) ---
+
+// Html\raw(): trusted content, emitted verbatim (the entity survives).
+echo <span title={\Html\raw('&nbsp;')}>x</span>, "\n";
+
+// Html\escape(): escaped exactly once, not re-escaped at render time.
+echo <span title={\Html\escape('a & b')}>x</span>, "\n";
+
+// Plain strings still escape by default.
+echo <span title={'a & b'}>x</span>, "\n";
+
+// A generic Stringable (not Htmlable) still escapes.
+class S { public function __toString(): string { return 'x & y'; } }
+echo <span title={new S}>x</span>, "\n";
+
+// --- Fragment, void elements, raw()/escape() helpers ---
+
+// Fragment: no wrapper element, children concatenated.
+$frag = new Fragment([
+    new Element('h1', [], ['Title']),
+    new Element('p', [], ['Body']),
+]);
+echo $frag->__toString(), "\n";
+
+// Void elements emit clean HTML5 (no slash, no closing tag).
+echo (new Element('br'))->__toString(), "\n";
+echo (new Element('img', ['src' => '/a.png', 'alt' => 'A & B']))->__toString(), "\n";
+
+// raw(): trusted passthrough, not escaped.
+echo raw('<b>x</b>')->__toString(), "\n";
+
+// escape(): escaped once, then safe to embed without double-escaping.
+$safe = escape('<b>x</b>');
+echo $safe->__toString(), "\n";
+echo (new Element('p', [], [$safe]))->__toString(), "\n"; // not escaped again
+
+var_dump(raw('y') instanceof Html\Htmlable);
+
+// --- tag/attribute-name validation (security) ---
+
+function err(callable $fn): string {
+    try { return $fn()->__toString(); }
+    catch (\Throwable $e) { return get_class($e) . ': ' . $e->getMessage(); }
+}
+
+// Attribute name from an attacker-controlled spread key - must be rejected.
+echo err(fn() => new E('a', ['x" onmouseover="alert(1)' => 'y'], ['hi'])), "\n";
+
+// Tag name from a dynamic source - must be rejected.
+echo err(fn() => new E('a><script>alert(1)</script>', [], [])), "\n";
+
+// Empty names rejected.
+echo err(fn() => new E('', [], [])), "\n";
+echo err(fn() => new E('div', ['' => 'x'], [])), "\n";
+
+// Legitimate dynamic names still work (custom elements, data-/aria-, namespaces).
+echo (new E('my-widget', ['data-x' => '1', 'aria-label' => 'ok', 'xml:lang' => 'en'], ['x']))->__toString(), "\n";
+echo (<a {...['data-id' => 5]}>ok</a>), "\n";
+?>
+--EXPECTF--
+<a href="https://php.net" class="btn">Click me</a>
+<a href="https://php.net" class="btn">Click me</a>
+bool(true)
+bool(true)
+string(1) "a"
+array(2) {
+  ["href"]=>
+  string(15) "https://php.net"
+  ["class"]=>
+  string(3) "btn"
+}
+array(1) {
+  [0]=>
+  string(8) "Click me"
+}
+<p>Tom &amp; Jerry &lt;3 &quot;quotes&quot; &#039;apostrophe&#039;</p>
+<div title="a &quot;b&quot; &amp; &lt;c&gt;"></div>
+<span>&lt;script&gt;alert(1)&lt;/script&gt;</span>
+<input type="checkbox" checked tabindex="3" data-ratio="1.5">
+<a data-x="x&amp;y"></a>
+TypeError: Attribute "class" value must be of type string|int|float|bool|null|Stringable, array given
+<span title="&nbsp;">x</span>
+<span title="a &amp; b">x</span>
+<span title="a &amp; b">x</span>
+<span title="x &amp; y">x</span>
+<h1>Title</h1><p>Body</p>
+<br>
+<img src="/a.png" alt="A &amp; B">
+<b>x</b>
+&lt;b&gt;x&lt;/b&gt;
+<p>&lt;b&gt;x&lt;/b&gt;</p>
+bool(true)
+ValueError: Invalid attribute name "x" onmouseover="alert(1)"
+ValueError: Invalid tag name "a><script>alert(1)</script>"
+ValueError: Invalid tag name ""
+ValueError: Invalid attribute name ""
+<my-widget data-x="1" aria-label="ok" xml:lang="en">x</my-widget>
+<a data-id="5">ok</a>
diff --git a/ext/html/tests/htmlable.phpt b/ext/html/tests/htmlable.phpt
new file mode 100644
index 000000000000..88c32c305d23
--- /dev/null
+++ b/ext/html/tests/htmlable.phpt
@@ -0,0 +1,171 @@
+--TEST--
+Html\Htmlable: toHtml() contract and recursive resolution, injected default __toString vs declared __toString, cycles and throwing implementations
+--EXTENSIONS--
+html
+--FILE--
+<?php
+declare(strict_types=1);
+
+// --- toHtml() contract ---
+
+// toHtml() returns the markup tree directly: no string cast is needed even
+// under strict_types, and the produced Element stays inspectable as an object.
+class Card implements Html\Htmlable {
+    public function __construct(private string $title) {}
+    public function toHtml(): Html\Htmlable {
+        return <div class="card">{$this->title}</div>;
+    }
+}
+
+$card = new Card('Hi & bye');
+var_dump($card->toHtml() instanceof Html\Element);
+var_dump($card->toHtml()->tag);
+
+// The injected default __toString renders via toHtml(), so echo, (string),
+// and interpolation all work without the class declaring __toString.
+echo $card, "\n";
+echo (string) $card, "\n";
+echo "wrapped: {$card}\n";
+var_dump($card instanceof Stringable);
+
+// In markup child position the component renders through toHtml() natively.
+echo <section>{$card}</section>, "\n";
+
+// And as a component tag.
+echo <Card title="Tagged"/>, "\n";
+
+// toHtml() may return another Htmlable (e.g. delegate to another component);
+// resolution recurses until it reaches a node class.
+class Fancy implements Html\Htmlable {
+    public function toHtml(): Html\Htmlable {
+        return new Card('delegated');
+    }
+}
+echo new Fancy(), "\n";
+
+// The node classes are the base cases: their toHtml() returns themselves.
+$el = <b>x</b>;
+var_dump($el->toHtml() === $el);
+$frag = <>y</>;
+var_dump($frag->toHtml() === $frag);
+$raw = Html\raw('<i>z</i>');
+var_dump($raw->toHtml() === $raw);
+
+// --- injected default __toString vs declared __toString ---
+
+// A __toString declared by the class wins for string casts; markup rendering
+// always goes through toHtml(), so the two can serve different audiences
+// (e.g. a log-friendly string form) without affecting markup output.
+class Custom implements Html\Htmlable {
+    public function toHtml(): Html\Htmlable { return <b>markup</b>; }
+    public function __toString(): string { return 'CUSTOM'; }
+}
+echo new Custom(), "\n";
+echo <i>{new Custom()}</i>, "\n";
+
+// A __toString flattened in from a trait counts as declared.
+trait Loud {
+    public function __toString(): string { return 'LOUD'; }
+}
+class UsesTrait implements Html\Htmlable {
+    use Loud;
+    public function toHtml(): Html\Htmlable { return Html\raw('quiet'); }
+}
+echo new UsesTrait(), " / ", <u>{new UsesTrait()}</u>, "\n";
+
+// A __toString inherited from a parent class also wins.
+class StringyBase {
+    public function __toString(): string { return 'BASE'; }
+}
+class ChildOfStringy extends StringyBase implements Html\Htmlable {
+    public function toHtml(): Html\Htmlable { return Html\raw('child'); }
+}
+echo new ChildOfStringy(), " / ", <u>{new ChildOfStringy()}</u>, "\n";
+
+// An abstract class implementing Htmlable: concrete children inherit the
+// injected default.
+abstract class Widget implements Html\Htmlable {}
+class Button extends Widget {
+    public function toHtml(): Html\Htmlable { return <button>ok</button>; }
+}
+echo new Button(), "\n";
+
+// An interface extending Htmlable stays abstract; implementers get the default.
+interface Panel extends Html\Htmlable {}
+class SidePanel implements Panel {
+    public function toHtml(): Html\Htmlable { return <aside>side</aside>; }
+}
+echo new SidePanel(), "\n";
+
+// The injected method is a real internal method: visible to reflection, with
+// the declared string return type, owned by the implementing class.
+$rm = new ReflectionMethod(SidePanel::class, '__toString');
+var_dump($rm->isInternal(), (string) $rm->getReturnType(), $rm->getDeclaringClass()->getName());
+var_dump(method_exists(new Button(), '__toString'));
+var_dump(is_callable([new Button(), '__toString']));
+echo (new Button())->__toString(), "\n";
+
+// --- resolution cycles and throwing implementations ---
+
+// toHtml() returning $this can never produce a node class: bounded, then Error.
+class Selfish implements Html\Htmlable {
+    public function toHtml(): Html\Htmlable { return $this; }
+}
+try { echo new Selfish(); }
+catch (Error $e) { echo get_class($e), ": ", $e->getMessage(), "\n"; }
+try { echo <div>{new Selfish()}</div>; }
+catch (Error $e) { echo get_class($e), ": ", $e->getMessage(), "\n"; }
+
+// A two-class cycle is caught by the same bound.
+class Ping implements Html\Htmlable {
+    public function toHtml(): Html\Htmlable { return new Pong(); }
+}
+class Pong implements Html\Htmlable {
+    public function toHtml(): Html\Htmlable { return new Ping(); }
+}
+try { echo new Ping(); }
+catch (Error $e) { echo get_class($e), ": ", $e->getMessage(), "\n"; }
+
+// An exception thrown inside toHtml() propagates cleanly through the injected
+// __toString (both directly and from child position).
+class Boom implements Html\Htmlable {
+    public function toHtml(): Html\Htmlable { throw new RuntimeException('boom'); }
+}
+try { echo new Boom(); }
+catch (RuntimeException $e) { echo get_class($e), ": ", $e->getMessage(), "\n"; }
+try { echo <div>{new Boom()}</div>; }
+catch (RuntimeException $e) { echo get_class($e), ": ", $e->getMessage(), "\n"; }
+
+echo "clean\n";
+?>
+--EXPECT--
+bool(true)
+string(3) "div"
+<div class="card">Hi &amp; bye</div>
+<div class="card">Hi &amp; bye</div>
+wrapped: <div class="card">Hi &amp; bye</div>
+bool(true)
+<section><div class="card">Hi &amp; bye</div></section>
+<div class="card">Tagged</div>
+<div class="card">delegated</div>
+bool(true)
+bool(true)
+bool(true)
+CUSTOM
+<i><b>markup</b></i>
+LOUD / <u>quiet</u>
+BASE / <u>child</u>
+<button>ok</button>
+<aside>side</aside>
+bool(true)
+string(6) "string"
+string(9) "SidePanel"
+bool(true)
+bool(true)
+<button>ok</button>
+Error: Maximum toHtml() resolution depth of 64 exceeded (Selfish::toHtml() never produced an Html\Element, Html\Fragment, or Html\Raw)
+Error: Maximum toHtml() resolution depth of 64 exceeded (Selfish::toHtml() never produced an Html\Element, Html\Fragment, or Html\Raw)
+Error: Maximum toHtml() resolution depth of 64 exceeded (Ping::toHtml() never produced an Html\Element, Html\Fragment, or Html\Raw)
+RuntimeException: boom
+RuntimeException: boom
+clean
diff --git a/ext/html/tests/htmlable_missing_tohtml.phpt b/ext/html/tests/htmlable_missing_tohtml.phpt
new file mode 100644
index 000000000000..efb3c74608a3
--- /dev/null
+++ b/ext/html/tests/htmlable_missing_tohtml.phpt
@@ -0,0 +1,12 @@
+--TEST--
+Html\Htmlable: a class implementing neither toHtml() nor __toString() only owes toHtml()
+--EXTENSIONS--
+html
+--FILE--
+<?php
+// __toString is satisfied by the injected default, so the one remaining
+// abstract requirement is toHtml() - the error must name only it.
+class Nope implements Html\Htmlable {}
+?>
+--EXPECTF--
+Fatal error: Class Nope contains 1 abstract method and must therefore be declared abstract or implement the remaining method (Html\Htmlable::toHtml) in %s on line %d
diff --git a/ext/html/tests/htmlable_tohtml_opcache.phpt b/ext/html/tests/htmlable_tohtml_opcache.phpt
new file mode 100644
index 000000000000..decb32061c37
--- /dev/null
+++ b/ext/html/tests/htmlable_tohtml_opcache.phpt
@@ -0,0 +1,34 @@
+--TEST--
+Html\Htmlable: the injected default __toString() survives opcache (arena-allocated internal method)
+--EXTENSIONS--
+html
+--SKIPIF--
+<?php if (!extension_loaded('Zend OPcache')) die('skip opcache not loaded'); ?>
+--INI--
+opcache.enable=1
+opcache.enable_cli=1
+--FILE--
+<?php
+declare(strict_types=1);
+
+class Card implements Html\Htmlable {
+    public function __construct(private string $title) {}
+    public function toHtml(): Html\Htmlable {
+        return <div class="card">{$this->title}</div>;
+    }
+}
+
+// Inheritance pushes the linked class (with its injected internal method)
+// through opcache's inheritance cache / persistence paths.
+class FancyCard extends Card {}
+
+echo new Card('a & b'), "\n";
+echo new FancyCard('c'), "\n";
+echo <section>{new Card('nested')}</section>, "\n";
+var_dump((new ReflectionMethod(FancyCard::class, '__toString'))->isInternal());
+?>
+--EXPECT--
+<div class="card">a &amp; b</div>
+<div class="card">c</div>
+<section><div class="card">nested</div></section>
+bool(true)
diff --git a/ext/html/tests/lazy_fragment.phpt b/ext/html/tests/lazy_fragment.phpt
new file mode 100644
index 000000000000..5905d99af2d0
--- /dev/null
+++ b/ext/html/tests/lazy_fragment.phpt
@@ -0,0 +1,65 @@
+--TEST--
+Markup syntax: the `:lazy` directive defers slot evaluation via Html\LazyFragment
+--EXTENSIONS--
+html
+--FILE--
+<?php
+use Html\Element as E;
+
+// An Auth component that renders its body only when "logged in". With `:lazy`
+// the body is never evaluated when discarded.
+class Auth implements Html\Htmlable {
+    public function __construct(public bool $check, #[Html\Slot] public ?Html\Htmlable $slot = null) {}
+    public function toHtml(): Html\Htmlable {
+        return $this->check ? new E('div', [], [$this->slot]) : new Html\Fragment([]);
+    }
+}
+
+$evaluated = 0;
+function track(): string { global $evaluated; $evaluated++; return 'secret'; }
+
+// Logged out: the body interpolation must never run.
+echo <Auth check={false} :lazy>Hello {track()}</Auth>, "\n";
+var_dump($evaluated); // 0 - never evaluated
+
+// Logged in: the body evaluates exactly once, even though a component could
+// in principle render its slot twice (LazyFragment memoizes).
+class Twice implements Html\Htmlable {
+    public function __construct(#[Html\Slot] public Html\Htmlable $slot) {}
+    public function toHtml(): Html\Htmlable {
+        return new Html\Fragment([$this->slot, $this->slot]);
+    }
+}
+$evaluated = 0;
+echo <Twice :lazy>x{track()}</Twice>, "\n";
+var_dump($evaluated); // 1 - memoized across both renders
+
+// Without `:lazy` the body is eager: track() runs before Auth even sees it.
+$evaluated = 0;
+echo <Auth check={false}>Hello {track()}</Auth>, "\n";
+var_dump($evaluated); // 1 - evaluated eagerly
+
+// The lowered value is an Html\LazyFragment that is itself an Html\Htmlable.
+$lazy = new Html\LazyFragment(fn() => new E('span', [], ['built']));
+var_dump($lazy instanceof Html\Htmlable);
+var_dump($lazy->toHtml() instanceof Html\Element);
+echo $lazy, "\n";
+
+// The thunk must return an Html\Htmlable.
+try {
+    (new Html\LazyFragment(fn() => 'nope'))->toHtml();
+} catch (\Error $e) {
+    echo $e->getMessage(), "\n";
+}
+?>
+--EXPECT--
+
+int(0)
+xsecretxsecret
+int(1)
+
+int(1)
+bool(true)
+bool(true)
+<span>built</span>
+Html\LazyFragment thunk must return an Html\Htmlable
diff --git a/ext/html/tests/syntax_attributes.phpt b/ext/html/tests/syntax_attributes.phpt
new file mode 100644
index 000000000000..be19f6459c60
--- /dev/null
+++ b/ext/html/tests/syntax_attributes.phpt
@@ -0,0 +1,131 @@
+--TEST--
+Markup syntax: attributes - literal/{expr}/bare-boolean with coercion, {...spread}, ":"/"@" prefixed names
+--EXTENSIONS--
+html
+--FILE--
+<?php
+use Html\Element as E;
+
+// --- literal, {expr}, bare boolean attributes with coercion ---
+$url = "/x?a=1&b=2";
+$id = 42;
+$on = true;
+$off = false;
+$missing = null;
+
+// literal value, {expr} value, int, bool true/false, null, bare boolean
+echo (<a href={$url} class="btn primary" data-id={$id} disabled={$on} hidden={$off} title={$missing} required>link</a>)->__toString(), "\n";
+
+// attribute value is escaped
+echo (<div title="a & b < c">x</div>)->__toString(), "\n";
+
+// self-closing element with attributes
+echo (<img src={$url} alt="A & B"/>)->__toString(), "\n";
+
+// --- {...$attrs} spread: elements (array merge) ---
+// Element: spread merges into the attribute map; values are still escaped.
+$extra = ['data-id' => 7, 'class' => 'from-spread', 'title' => 'T & T'];
+echo (<a href="/x" {...$extra}>link</a>)->__toString(), "\n";
+
+// Conflict resolution follows array-merge order (last wins).
+echo (<a class="base" {...['class' => 'override']}>x</a>)->__toString(), "\n";
+echo (<a {...['class' => 'base']} class="explicit">x</a>)->__toString(), "\n";
+
+// --- {...$attrs} spread: components (named args) ---
+// Component: spread becomes named arguments (props).
+class Card implements Html\Htmlable {
+    public function __construct(public string $title, public string $tone = 'plain') {}
+    public function toHtml(): Html\Htmlable {
+        return new E('div', ['class' => 'card-' . $this->tone], [$this->title]);
+    }
+}
+$props = ['title' => 'Hi & bye', 'tone' => 'loud'];
+echo (<Card {...$props}/>)->__toString(), "\n";
+echo (<Card title="Explicit" {...['tone' => 'soft']}/>)->__toString(), "\n";
+
+// A component variadic collects unknown (e.g. hyphenated) spread keys.
+class Box implements Html\Htmlable {
+    private array $attrs;
+    public function __construct(public string $kind, ...$attrs) { $this->attrs = $attrs; }
+    public function toHtml(): Html\Htmlable {
+        return new E('div', ['class' => $this->kind, ...$this->attrs], ['box']);
+    }
+}
+echo (<Box kind="b" {...['data-x' => '1', 'role' => 'note']}/>)->__toString(), "\n";
+
+// --- ":" / "@" as an optional leading character of attribute names ---
+// Vue/Alpine shorthand attribute names: literal value, {expr} value, bare boolean.
+$open = 'open';
+echo <div :class="{ active: open }" @click="open = !open">t</div>, "\n";
+echo <button @click={$open . '()'} :disabled>go</button>, "\n";
+
+// The prefix composes with the rest of the name charset (Alpine long forms,
+// modifiers) - only the *leading* character is new.
+echo <input @keydown.escape="close()" :aria-label="label"/>, "\n";
+
+// Prefixed keys also pass the runtime name validation: spread and new Element.
+$attrs = ['@click' => 'save()', ':class' => 'cls'];
+echo <span {...$attrs}>s</span>, "\n";
+echo new Html\Element('i', ['@x' => '1'], []), "\n";
+
+// On a component the names were never valid named-argument labels, so - like
+// data-* - they are collected by a variadic.
+class Btn implements Html\Htmlable {
+    private array $attrs;
+    public function __construct(public string $label, ...$attrs) { $this->attrs = $attrs; }
+    public function toHtml(): Html\Htmlable {
+        return <button {...$this->attrs}>{$this->label}</button>;
+    }
+}
+echo <Btn label="Save" @click="save()" :class="btn"/>, "\n";
+
+// Attribute values are still escaped like any other.
+echo <div :class={'a & "b"'}>x</div>, "\n";
+
+// Attribute position only: a prefixed name can never begin a tag. At top
+// level "<:" / "<@" do not start markup at all; nested in markup content a
+// stray "<" gives the dedicated error.
+try {
+    eval('$x = <div><:foo/></div>;');
+} catch (ParseError $e) {
+    echo $e->getMessage(), "\n";
+}
+try {
+    eval('$x = <div><@click/></div>;');
+} catch (ParseError $e) {
+    echo $e->getMessage(), "\n";
+}
+
+// The prefix must be followed by a letter, and closing tags take no attributes.
+try {
+    eval('$x = <div @>t</div>;');
+} catch (ParseError $e) {
+    echo $e->getMessage(), "\n";
+}
+try {
+    eval('$x = <div>t</div @x>;');
+} catch (ParseError $e) {
+    echo $e->getMessage(), "\n";
+}
+?>
+--EXPECT--
+<a href="/x?a=1&amp;b=2" class="btn primary" data-id="42" disabled required>link</a>
+<div title="a &amp; b &lt; c">x</div>
+<img src="/x?a=1&amp;b=2" alt="A &amp; B">
+<a href="/x" data-id="7" class="from-spread" title="T &amp; T">link</a>
+<a class="override">x</a>
+<a class="explicit">x</a>
+<div class="card-loud">Hi &amp; bye</div>
+<div class="card-soft">Explicit</div>
+<div class="b" data-x="1" role="note">box</div>
+<div :class="{ active: open }" @click="open = !open">t</div>
+<button @click="open()" :disabled>go</button>
+<input @keydown.escape="close()" :aria-label="label">
+<span @click="save()" :class="cls">s</span>
+<i @x="1"></i>
+<button @click="save()" :class="btn">Save</button>
+<div :class="a &amp; &quot;b&quot;">x</div>
+Unescaped "<" in markup text; write {'<'} for a literal less-than sign
+Unescaped "<" in markup text; write {'<'} for a literal less-than sign
+syntax error, unexpected T_ERROR "@", expecting markup tag name or markup tag end or markup self-close or markup interpolation start
+syntax error, unexpected T_ERROR "@", expecting markup tag end
diff --git a/ext/html/tests/syntax_basic.phpt b/ext/html/tests/syntax_basic.phpt
new file mode 100644
index 000000000000..ca63a9717570
--- /dev/null
+++ b/ext/html/tests/syntax_basic.phpt
@@ -0,0 +1,176 @@
+--TEST--
+Markup syntax: elements, fragments, interpolation, whitespace, childless/self-close, literal braces, comments
+--EXTENSIONS--
+html
+--FILE--
+<?php
+// --- elements, interpolation, nesting, fragments ---
+$name = "Ada & <friends>";
+
+// Element with interpolation and a nested element.
+$el = <div>Hello {$name} <em>world</em></div>;
+var_dump($el instanceof Html\Element);
+echo $el->__toString(), "\n";
+
+// Fragment (no wrapper).
+$frag = <><h1>Title</h1><p>Body {$name}</p></>;
+var_dump($frag instanceof Html\Fragment);
+echo $frag->__toString(), "\n";
+
+// Interpolation can hold any expression; arrays flatten, null renders "".
+$items = ['x', 'y'];
+echo (<ul>{array_map(fn($i) => <li>{$i}</li>, $items)}</ul>)->__toString(), "\n";
+echo (<p>{true ? 'yes' : null}</p>)->__toString(), "\n";
+
+// --- JSX-style whitespace normalization ---
+// Newlines + indentation between block elements are dropped.
+echo (<ul>
+    <li>one</li>
+    <li>two</li>
+</ul>)->__toString(), "\n";
+
+// A meaningful single space between inline content is preserved.
+$who = 'Ada';
+echo (<p>Hello {$who}, <em>welcome</em> back</p>)->__toString(), "\n";
+
+// Leading/trailing blank lines and indentation around text collapse away.
+echo (<p>
+    Just some text.
+</p>)->__toString(), "\n";
+
+// Words on separate lines join with a single space.
+echo (<p>
+    one
+    two
+    three
+</p>)->__toString(), "\n";
+
+// Inline trailing space with no newline is kept (so adjacent elements don't fuse).
+echo (<p>a <b>b</b> c</p>)->__toString(), "\n";
+
+// --- childless elements: empty or self-closed are equivalent ---
+// <div></div> and <div/> are equivalent - both allowed, so real HTML can be
+// pasted into markup unchanged.
+var_dump((string) <div></div> === (string) <div/>);
+echo <div></div>, "\n";
+echo <span class="a"></span>, "\n";
+
+// A whitespace-only multi-line body normalizes away to the same empty element.
+echo <div>
+</div>, "\n";
+
+// Void elements still serialize with no closing tag, from either source form.
+echo <br/>, "\n";
+echo <br></br>, "\n";
+
+// --- self-closing source; serializer expands non-void elements ---
+// Void elements serialize without a closing tag...
+echo (<img/>)->__toString(), "\n";
+echo (<img src="/a.png"/>)->__toString(), "\n";
+// ...non-void self-closed source expands to open+close output.
+echo (<div/>)->__toString(), "\n";
+echo (<span class="x"/>)->__toString(), "\n";
+
+// Empty components and fragments are allowed (only HTML elements must self-close).
+class C implements Html\Htmlable {
+    public function toHtml(): Html\Htmlable { return Html\raw('C'); }
+}
+echo (<C></C>)->__toString(), "\n";
+var_dump((<></>)->__toString());
+
+// --- literal braces via character references or {'{'} ---
+// { begins interpolation; a literal { is written as in HTML or JSX.
+
+// Character references decode to literal braces at compile time (no interpolation).
+echo (<p>&#123;x&#125;</p>)->__toString(), "\n";
+echo (<p>&lbrace;x&rbrace;</p>)->__toString(), "\n";
+
+// The JSX form: an interpolated string literal.
+echo (<p>{'{'}x{'}'}</p>)->__toString(), "\n";
+
+// A lone } in text is already literal.
+echo (<p>a } b</p>)->__toString(), "\n";
+
+// Literal JSON in a <script> uses the raw() island pattern (text children are
+// HTML-escaped, and browsers never entity-decode inside raw-text elements).
+echo (<script type="application/json" id="config">{Html\raw(<<<'JSON'
+{"@type": "Article", "title": "Braces & quotes stay verbatim"}
+JSON)}</script>)->__toString(), "\n";
+
+// --- comments: <!-- --> is literal output; {/* */} renders nothing ---
+$x = 'ignored';
+
+// <!-- --> is emitted verbatim; its content is literal (no interpolation).
+echo (<div><!-- a literal {$x} comment --><p>body</p></div>)->__toString(), "\n";
+
+// {/* ... */} is a source-only comment and renders nothing.
+echo (<p>a{/* dropped */}b</p>)->__toString(), "\n";
+
+// an empty interpolation renders nothing too
+echo (<p>x{}y</p>)->__toString(), "\n";
+
+// comment between block elements survives (it is real output, not whitespace)
+echo (<ul>
+    <!-- first -->
+    <li>one</li>
+</ul>)->__toString(), "\n";
+
+// --- operand positions: markup lexes after every operand-expecting token ---
+// (the scanner's allowlist; a comparison never silently changes meaning)
+echo "concat " . <u>c</u>, "\n";                      // after "."
+echo true ? <s>t</s> : <s>f</s>, "\n";                // after "?" and ":"
+echo null ?? <em>coal</em>, "\n";                     // after "??"
+echo (string) <p>cast</p>, "\n";                      // after a cast
+echo <div>pipe</div> |> strtoupper(...), "\n";        // after "|>"
+echo clone <span>cl</span>, "\n";                     // after `clone`
+print <p>print</p>; echo "\n";                        // after `print`
+echo [<b>a</b>, <b>b</b>][1], "\n";                   // after "[" and ","
+echo (fn() => <li>arrow</li>)(), "\n";                // after "=>"
+echo match(true) { true => <b>match</b> }, "\n";      // match arm "=>"
+function gen() { yield from [<i>yf</i>]; }            // after `yield from`
+echo iterator_to_array(gen())[0], "\n";
+?>
+--EXPECT--
+bool(true)
+<div>Hello Ada &amp; &lt;friends&gt; <em>world</em></div>
+bool(true)
+<h1>Title</h1><p>Body Ada &amp; &lt;friends&gt;</p>
+<ul><li>x</li><li>y</li></ul>
+<p>yes</p>
+<ul><li>one</li><li>two</li></ul>
+<p>Hello Ada, <em>welcome</em> back</p>
+<p>Just some text.</p>
+<p>one two three</p>
+<p>a <b>b</b> c</p>
+bool(true)
+<div></div>
+<span class="a"></span>
+<div></div>
+<br>
+<br>
+<img>
+<img src="/a.png">
+<div></div>
+<span class="x"></span>
+C
+string(0) ""
+<p>{x}</p>
+<p>{x}</p>
+<p>{x}</p>
+<p>a } b</p>
+<script type="application/json" id="config">{"@type": "Article", "title": "Braces & quotes stay verbatim"}</script>
+<div><!-- a literal {$x} comment --><p>body</p></div>
+<p>ab</p>
+<p>xy</p>
+<ul><!-- first --><li>one</li></ul>
+concat <u>c</u>
+<s>t</s>
+<em>coal</em>
+<p>cast</p>
+<DIV>PIPE</DIV>
+<span>cl</span>
+<p>print</p>
+<b>b</b>
+<li>arrow</li>
+<b>match</b>
+<i>yf</i>
diff --git a/ext/html/tests/syntax_component_resolution.phpt b/ext/html/tests/syntax_component_resolution.phpt
new file mode 100644
index 000000000000..7a1ad325938f
--- /dev/null
+++ b/ext/html/tests/syntax_component_resolution.phpt
@@ -0,0 +1,100 @@
+--TEST--
+Markup syntax: compile-time component-name resolution (use aliases, qualified/fully-qualified tags, static methods)
+--EXTENSIONS--
+html
+--FILE--
+<?php
+// --- component definitions ---
+namespace App\Components {
+    use Html\Element as E;
+    class Card implements \Html\Htmlable {
+        public function __construct(public string $title) {}
+        public function toHtml(): \Html\Htmlable {
+            return new E('div', ['class' => 'card'], [$this->title]);
+        }
+    }
+}
+
+namespace App {
+    class Greeting implements \Html\Htmlable {
+        public function __construct(#[\Html\Slot] public ?\Html\Htmlable $slot = null) {}
+        public function toHtml(): \Html\Htmlable {
+            return <p>{$this->slot}</p>;
+        }
+    }
+    class Card implements \Html\Htmlable {
+        public function __construct(public string $title) {}
+        public function toHtml(): \Html\Htmlable {
+            return new \Html\Element('b', [], [$this->title]);
+        }
+    }
+    class Author {
+        public static function byline(string $name): \Html\Htmlable {
+            return new \Html\Element('i', [], ['By ', $name]);
+        }
+    }
+}
+
+// --- use-alias resolution from another namespace ---
+namespace App\Views {
+    use App\Components\Card;
+    // <Card> resolves to App\Components\Card via the `use` alias, not a global Card.
+    echo (<Card title="Hi & ok"/>)->__toString(), "\n";
+    echo (<div><Card title="Nested"/></div>)->__toString(), "\n";
+}
+
+// --- qualified (namespace-relative) tags from global scope ---
+namespace {
+    // A qualified name is namespace-relative; from global scope App\Greeting is App\Greeting.
+    echo (<App\Greeting>hi</App\Greeting>)->__toString(), "\n";
+    echo (<App\Card title="G"/>)->__toString(), "\n";
+}
+
+// --- fully-qualified tags, use imports, static-method class-part resolution ---
+namespace Views {
+    // A fully-qualified <\...> tag ignores the current namespace.
+    echo (<\App\Greeting>fq</\App\Greeting>)->__toString(), "\n";
+
+    // A class component is imported with `use`, like any class.
+    use App\Card;
+    echo (<Card title="C"/>)->__toString(), "\n";
+
+    // A static-method tag's class part resolves the same way: qualified,
+    // fully-qualified, or through the class `use` table.
+    echo (<\App\Author::byline name="Ada"/>)->__toString(), "\n";
+    use App\Author;
+    echo (<Author::byline name="Grace"/>)->__toString(), "\n";
+}
+
+// --- component defined and used in the current namespace ---
+namespace Other {
+    use Html\Element as E;
+    class Box implements \Html\Htmlable {
+        public function __construct(public string $label) {}
+        public function toHtml(): \Html\Htmlable { return new E('b', [], [$this->label]); }
+    }
+    echo (<Box label="local"/>)->__toString(), "\n";
+}
+
+// --- unimported bare tag fails: no global fallback ---
+namespace Wrong {
+    // Without an import, a bare tag resolves in the current namespace only -
+    // exactly how PHP resolves an unqualified class name (no global fallback).
+    try {
+        echo (<Card title="x"/>)->__toString(), "\n";
+    } catch (\Error $e) {
+        echo $e->getMessage(), "\n";
+    }
+}
+?>
+--EXPECT--
+<div class="card">Hi &amp; ok</div>
+<div><div class="card">Nested</div></div>
+<p>hi</p>
+<b>G</b>
+<p>fq</p>
+<b>C</b>
+<i>By Ada</i>
+<i>By Grace</i>
+<b>local</b>
+"Wrong\Card" is not a component: no such class implementing Html\Htmlable
diff --git a/ext/html/tests/syntax_doctype.phpt b/ext/html/tests/syntax_doctype.phpt
new file mode 100644
index 000000000000..3de7054b0e5c
--- /dev/null
+++ b/ext/html/tests/syntax_doctype.phpt
@@ -0,0 +1,50 @@
+--TEST--
+Markup syntax: <!DOCTYPE html> emission rules and non-doctype <! parse errors
+--EXTENSIONS--
+html
+--FILE--
+<?php
+// --- doctype emission ---
+$x = 'ignored';
+
+// A full document: doctype in a fragment, emitted verbatim before the root element.
+echo (<>
+    <!DOCTYPE html>
+    <html lang="en"><body><p>hi</p></body></html>
+</>)->__toString(), "\n";
+
+// Case-insensitive, and content is literal (no interpolation).
+echo (<><!doctype html {$x}><div></div></>)->__toString(), "\n";
+
+// Legacy doctypes with public/system identifiers pass through too.
+echo (<><!DOCTYPE html PUBLIC "-//W3C//DTD XHTML 1.0 Strict//EN" "http://www.w3.org/TR/xhtml1/DTD/xhtml1-strict.dtd"><p>x</p></>)->__toString(), "\n";
+
+// Position is not validated: emitted where written, like a comment.
+echo (<div><!DOCTYPE html><span>s</span></div>)->__toString(), "\n";
+
+// --- non-doctype <! declarations are a targeted parse error ---
+try {
+    eval('$v = <svg><![CDATA[ x < y ]]></svg>;');
+} catch (ParseError $e) {
+    echo $e->getMessage(), "\n";
+}
+try {
+    eval('$v = <div><!ELEMENT foo></div>;');
+} catch (ParseError $e) {
+    echo $e->getMessage(), "\n";
+}
+// An unterminated doctype must not scan past the end of the file.
+try {
+    eval('$v = <div><!doctype html');
+} catch (ParseError $e) {
+    echo $e->getMessage(), "\n";
+}
+?>
+--EXPECTF--
+<!DOCTYPE html><html lang="en"><body><p>hi</p></body></html>
+<!doctype html {$x}><div></div>
+<!DOCTYPE html PUBLIC "-//W3C//DTD XHTML 1.0 Strict//EN" "http://www.w3.org/TR/xhtml1/DTD/xhtml1-strict.dtd"><p>x</p>
+<div><!DOCTYPE html><span>s</span></div>
+Unsupported markup declaration; only <!-- --> comments and <!doctype> are supported
+Unsupported markup declaration; only <!-- --> comments and <!doctype> are supported
+%s
diff --git a/ext/html/tests/syntax_dynamic.phpt b/ext/html/tests/syntax_dynamic.phpt
new file mode 100644
index 000000000000..8ff87fb04d91
--- /dev/null
+++ b/ext/html/tests/syntax_dynamic.phpt
@@ -0,0 +1,177 @@
+--TEST--
+Markup syntax: dynamic tags <$tag>/<{expr}> - classification, escaping, single evaluation, BC, error cases
+--EXTENSIONS--
+html
+--FILE--
+<?php
+// --- <$tag> variable elements ---
+// An element name: behaves exactly like the static tag.
+$tag = 'div';
+$el = <$tag class="box">Hello</$tag>;
+var_dump($el instanceof Html\Element);
+echo $el, "\n";
+
+// Self-close; void elements serialize as voids.
+$tag = 'br';
+echo <$tag/>, "\n";
+$tag = 'section';
+echo <$tag id="main" hidden>Text {1 + 1}</$tag>, "\n";
+
+// Nested inside static markup, with spread attributes.
+$tag = 'em';
+$attrs = ['class' => 'x'];
+echo <div><$tag {...$attrs}>hi</$tag></div>, "\n";
+
+// --- runtime classification: components ---
+// A class-component name (::class gives the FQCN): full component dispatch.
+class Card implements Html\Htmlable {
+    public function __construct(
+        private string $title,
+        #[Html\Slot] private ?Html\Htmlable $body = null,
+    ) {}
+    public function toHtml(): Html\Htmlable {
+        return <article><h1>{$this->title}</h1>{$this->body}</article>;
+    }
+}
+$component = Card::class;
+echo <$component title="Hi"/>, "\n";
+echo <$component title="Hi">Body</$component>, "\n";
+
+// A "Class::method" value dispatches as a static-method component.
+class Author {
+    public static function byline(string $name): Html\Htmlable {
+        return <i>By {$name}</i>;
+    }
+}
+$component = 'Author::byline';
+echo <$component name="Ada"/>, "\n";
+
+// --- escaping ---
+// Interpolated content is still escaped, whatever the tag value.
+$tag = 'span';
+$evil = '<script>alert(1)</script>';
+echo <$tag>{$evil}</$tag>, "\n";
+
+// --- <{expr}> brace form: arbitrary expression, anonymous close ---
+// The brace form takes an arbitrary expression, evaluated once, and closes
+// anonymously with </> (or self-closes).
+class Registry {
+    public function getComponentName(): string { return 'div'; }
+}
+$object = new Registry;
+echo <{$object->getComponentName()} class="x">Hello</>, "\n";
+$important = true;
+echo <{$important ? 'strong' : 'span'}>note</>, "\n";
+echo <{Card::class} title="Braced"/>, "\n";
+
+$calls = 0;
+function tag_once(): string { global $calls; $calls++; return 'p'; }
+echo <{tag_once()}>once</>, "\n";
+var_dump($calls);
+
+// Brace tags nest like any other element.
+echo <div><{'em'}>in <b>here</b></></div>, "\n";
+
+// --- operator-position "<$" keeps its comparison meaning (BC) ---
+$a = 5;
+$b = 9;
+var_dump($a <$b, $b <$a);
+
+// --- render_dynamic() direct calls ---
+// The runtime target is a public function, same as render_component().
+echo Html\render_dynamic('p', ['class' => 'y'], ['direct']), "\n";
+echo Html\render_dynamic(Card::class, ['title' => 'Direct']), "\n";
+
+// --- error cases ---
+// Mismatched closing variable is a compile error, like </div> for <span>.
+try {
+    eval('$x = <$a>hi</$b>;');
+} catch (CompileError $e) {
+    echo $e->getMessage(), "\n";
+}
+
+// A brace tag closes anonymously; a named or variable close is a parse error
+// (the expression cannot be restated without re-evaluating it).
+foreach (['$x = <{"div"}>a</div>;', '$x = <{"div"}>a</$t>;'] as $code) {
+    try {
+        eval($code);
+    } catch (ParseError $e) {
+        echo $e->getMessage(), "\n";
+    }
+}
+
+// An empty tag value is rejected up front.
+try {
+    Html\render_dynamic('');
+} catch (ValueError $e) {
+    echo $e->getMessage(), "\n";
+}
+
+// A value that is no valid tag name fails at serialization (the existing
+// Element guard) - a dynamic name can never break out of the markup.
+$tag = 'di v';
+try {
+    echo (string) <$tag/>;
+} catch (Error $e) {
+    echo $e->getMessage(), "\n";
+}
+
+// A lowercase value is always an element, even if a function of that name
+// exists (the same rule that makes static <date> an element).
+$tag = 'date';
+echo <$tag/>, "\n";
+
+// A capitalized value can never reach an internal function like Date().
+$tag = 'Date';
+try {
+    echo <$tag/>;
+} catch (Error $e) {
+    echo $e->getMessage(), "\n";
+}
+
+// A capitalized value with no symbol behind it.
+$tag = 'NoSuchComponent';
+try {
+    echo <$tag/>;
+} catch (Error $e) {
+    echo $e->getMessage(), "\n";
+}
+
+// A "Class::method" value dispatches as a static-method component; a missing
+// class is the same hard error the static tag form gives.
+$tag = 'NoSuchRegistry::make';
+try {
+    echo <$tag/>;
+} catch (Error $e) {
+    echo $e->getMessage(), "\n";
+}
+?>
+--EXPECT--
+bool(true)
+<div class="box">Hello</div>
+<br>
+<section id="main" hidden>Text 2</section>
+<div><em class="x">hi</em></div>
+<article><h1>Hi</h1></article>
+<article><h1>Hi</h1>Body</article>
+<i>By Ada</i>
+<span>&lt;script&gt;alert(1)&lt;/script&gt;</span>
+<div class="x">Hello</div>
+<strong>note</strong>
+<article><h1>Braced</h1></article>
+<p>once</p>
+int(1)
+<div><em>in <b>here</b></em></div>
+bool(true)
+bool(false)
+<p class="y">direct</p>
+<article><h1>Direct</h1></article>
+Mismatched markup closing tag: expected </$a>, found </$b>
+syntax error, unexpected markup tag name "div", expecting markup tag end
+syntax error, unexpected variable "$t", expecting markup tag end
+Html\render_dynamic(): Argument #1 ($tag) cannot be empty
+Invalid tag name "di v"
+<date></date>
+"Date" is not a component: no such class implementing Html\Htmlable
+"NoSuchComponent" is not a component: no such class implementing Html\Htmlable
+Component class "NoSuchRegistry" not found
diff --git a/ext/html/tests/syntax_entities.phpt b/ext/html/tests/syntax_entities.phpt
new file mode 100644
index 000000000000..4cd7a97e5ce6
--- /dev/null
+++ b/ext/html/tests/syntax_entities.phpt
@@ -0,0 +1,73 @@
+--TEST--
+Markup syntax: HTML character references decode in text/attributes; tokenizer keeps them raw
+--EXTENSIONS--
+html
+tokenizer
+--FILE--
+<?php
+// --- named and numeric character references in text ---
+// Named entities decode to their UTF-8 text; the ampersand round-trips:
+// "&amp;" in source is "&" in the value, re-escaped to "&amp;" on output.
+echo <p>Fish &amp; chips &mdash; &pound;5</p>, "\n";
+
+// Case matters, exactly as in HTML: &Aacute; and &aacute; differ.
+echo <p>&Aacute; vs &aacute;</p>, "\n";
+
+// Numeric references: decimal, hex (either x/X case), multi-codepoint named.
+echo <p>&#65;&#x42;&#X43; &#x1F600; &nGt;</p>, "\n";
+
+// &nbsp; is a real U+00A0, not the entity text (htmlspecialchars leaves it alone).
+var_dump((string)<i>&nbsp;</i> === "<i>\u{00A0}</i>");
+
+// --- lenient handling of invalid references ---
+// Lenient like HTML/JSX: unknown names, bare "&", missing semicolons,
+// and invalid numerics (zero, surrogate, out of range, empty) stay literal
+// and are escaped on output.
+echo <p>a & b &nosuchentity; &amp c</p>, "\n";
+echo <p>&#0; &#xD800; &#x110000; &#; &#x; &#xG;</p>, "\n";
+
+// --- attribute values ---
+// Attribute values decode too; the "&" re-escapes when serialized.
+echo <a title="Caf&eacute; &amp; bar" data-x="&#x2764;">x</a>, "\n";
+
+// --- entities cannot smuggle markup structure ---
+// lt/gt decode to real angle brackets in the value, escaped on output --
+// so entities cannot smuggle markup structure.
+echo <p>&lt;script&gt;alert(1)&lt;/script&gt;</p>, "\n";
+
+// --- interaction with whitespace normalization, comments, interpolation ---
+// Entities decode after whitespace normalization, so &#32; survives where a
+// literal trailing space would be trimmed (the entity spelling of JSX {' '}).
+echo <p>a&#32;
+</p>, "\n";
+
+// Entities inside <!-- comments --> stay verbatim (comments are raw output).
+echo <div><!-- &amp; &#65; --></div>, "\n";
+
+// Interpolated strings are never entity-decoded; they are plain PHP values.
+echo <p>{"&amp;"}</p>, "\n";
+
+// --- tokenizer round-trip ---
+// Entity decoding happens only for the compiler; the tokenizer must see the
+// raw source text so token streams concatenate back to the original file.
+$code = '<?php echo <p title="Caf&eacute;">Fish &amp; chips &#x2764;</p>; ?>';
+
+$joined = '';
+foreach (token_get_all($code) as $token) {
+    $joined .= is_array($token) ? $token[1] : $token;
+}
+var_dump($joined === $code);
+?>
+--EXPECT--
+<p>Fish &amp; chips — £5</p>
+<p>Á vs á</p>
+<p>ABC 😀 ≫⃒</p>
+bool(true)
+<p>a &amp; b &amp;nosuchentity; &amp;amp c</p>
+<p>&amp;#0; &amp;#xD800; &amp;#x110000; &amp;#; &amp;#x; &amp;#xG;</p>
+<a title="Café &amp; bar" data-x="❤">x</a>
+<p>&lt;script&gt;alert(1)&lt;/script&gt;</p>
+<p>a </p>
+<div><!-- &amp; &#65; --></div>
+<p>&amp;amp;</p>
+bool(true)
diff --git a/ext/html/tests/syntax_lineno.phpt b/ext/html/tests/syntax_lineno.phpt
new file mode 100644
index 000000000000..8f6da8678e15
--- /dev/null
+++ b/ext/html/tests/syntax_lineno.phpt
@@ -0,0 +1,37 @@
+--TEST--
+Markup syntax: multi-line elements report errors on the opening-tag line, like any multi-line call
+--EXTENSIONS--
+html
+--FILE--
+<?php
+class Card implements Html\Htmlable {
+    public function __construct(private string $title) {}
+    public function toHtml(): Html\Htmlable { return <div>{$this->title}</div>; }
+}
+
+// Static component spanning lines: the render_component call site is the
+// opening <Card line, not the closing </Card> line.
+try {
+    echo <Card
+        title={[]}
+    >
+    </Card>;
+} catch (TypeError $e) {
+    /* trace: [0] the internal ctor frame (no line), [1] the render_component
+     * call site - which must be the opening-tag line. */
+    echo "component call site: line ", $e->getTrace()[1]['line'], "\n";
+}
+
+// Dynamic tag spanning lines: same rule.
+$var = new stdClass;
+try {
+    echo <$var>
+        body
+    </$var>;
+} catch (TypeError $e) {
+    echo "dynamic tag: line ", $e->getLine(), "\n";
+}
+?>
+--EXPECT--
+component call site: line 10
+dynamic tag: line 23
diff --git a/ext/html/tests/syntax_lowering.phpt b/ext/html/tests/syntax_lowering.phpt
new file mode 100644
index 000000000000..a338ead7989b
--- /dev/null
+++ b/ext/html/tests/syntax_lowering.phpt
@@ -0,0 +1,49 @@
+--TEST--
+Markup syntax: the exact plain-PHP lowering, pinned via zend_ast_export (assert)
+--EXTENSIONS--
+html
+--INI--
+zend.assertions=1
+assert.exception=1
+--FILE--
+<?php
+// A failed assert() exports the compiled expression back to source
+// (zend_ast_export). Markup is lowered during parsing, so the message shows
+// exactly the plain-PHP form each construct compiles to - with `false &&`
+// short-circuiting, nothing is ever evaluated or rendered. This pins the
+// documented desugarings without any dedicated introspection API.
+function desugar(string $expr): string {
+    try {
+        eval("assert(false && ($expr));");
+    } catch (AssertionError $e) {
+        return substr($e->getMessage(), strlen("assert(false && "), -1);
+    }
+    return "NO EXPORT";
+}
+
+// A plain element with a literal and an interpolated attribute.
+echo desugar('<div class="box" id={$id}>Hello {$name}</div>'), "\n";
+
+// Fragment, component with props + spread, nested element body.
+echo desugar('<><Card title="Hi" {...$attrs}><b>f</b>body</Card></>'), "\n";
+
+// A static-method tag resolves its class part like any class name.
+echo desugar('<Author::byline name="Ada"/>'), "\n";
+
+// The `:lazy` directive wraps the body in a deferred Html\LazyFragment.
+echo desugar('<Auth :lazy>Hello {$name}</Auth>'), "\n";
+
+// Dynamic tags lower to Html\render_dynamic.
+echo desugar('<$tag class="x">{$content}</$tag>'), "\n";
+
+// Character references are decoded at compile time, so the exported string
+// literal contains the decoded text.
+echo desugar('<p>Fish &amp; chips &mdash; &pound;5</p>'), "\n";
+?>
+--EXPECT--
+new \Html\Element('div', ['class' => 'box', 'id' => $id], ['Hello ', $name])
+new \Html\Fragment([\Html\render_component(Card::class, ['title' => 'Hi', ...$attrs], new \Html\Fragment([new \Html\Element('b', [], ['f']), 'body']))])
+\Html\render_component(Author::class . '::byline', ['name' => 'Ada'], null)
+\Html\render_component(Auth::class, [], new \Html\LazyFragment(fn() => new \Html\Fragment(['Hello ', $name])))
+\Html\render_dynamic($tag, ['class' => 'x'], [$content])
+new \Html\Element('p', [], ['Fish & chips — £5'])
diff --git a/ext/html/tests/syntax_mismatch.phpt b/ext/html/tests/syntax_mismatch.phpt
new file mode 100644
index 000000000000..a11b3e3b2a6c
--- /dev/null
+++ b/ext/html/tests/syntax_mismatch.phpt
@@ -0,0 +1,10 @@
+--TEST--
+Markup syntax: a mismatched closing tag is a compile error
+--EXTENSIONS--
+html
+--FILE--
+<?php
+$x = <div>oops</span>;
+?>
+--EXPECTF--
+Fatal error: Mismatched markup closing tag: expected </div>, found </span> in %s on line %d
diff --git a/ext/tokenizer/tokenizer_data.c b/ext/tokenizer/tokenizer_data.c
index 87b15b8bb345..47ce453d59de 100644
--- a/ext/tokenizer/tokenizer_data.c
+++ b/ext/tokenizer/tokenizer_data.c
@@ -175,6 +175,16 @@ char *get_token_type_name(int token_type)
 		case T_AMPERSAND_FOLLOWED_BY_VAR_OR_VARARG: return "T_AMPERSAND_FOLLOWED_BY_VAR_OR_VARARG";
 		case T_AMPERSAND_NOT_FOLLOWED_BY_VAR_OR_VARARG: return "T_AMPERSAND_NOT_FOLLOWED_BY_VAR_OR_VARARG";
 		case T_BAD_CHARACTER: return "T_BAD_CHARACTER";
+		case T_MARKUP_NAME: return "T_MARKUP_NAME";
+		case T_MARKUP_TEXT: return "T_MARKUP_TEXT";
+		case T_MARKUP_ATTR_VALUE: return "T_MARKUP_ATTR_VALUE";
+		case T_MARKUP_COMMENT: return "T_MARKUP_COMMENT";
+		case T_MARKUP_OPEN: return "T_MARKUP_OPEN";
+		case T_MARKUP_CLOSE_OPEN: return "T_MARKUP_CLOSE_OPEN";
+		case T_MARKUP_TAG_END: return "T_MARKUP_TAG_END";
+		case T_MARKUP_SELF_CLOSE: return "T_MARKUP_SELF_CLOSE";
+		case T_MARKUP_INTERP_START: return "T_MARKUP_INTERP_START";
+		case T_MARKUP_DOCTYPE: return "T_MARKUP_DOCTYPE";
 
 	}
 	return NULL;
diff --git a/ext/tokenizer/tokenizer_data.stub.php b/ext/tokenizer/tokenizer_data.stub.php
index 57c8edad8acb..2f137a272c2e 100644
--- a/ext/tokenizer/tokenizer_data.stub.php
+++ b/ext/tokenizer/tokenizer_data.stub.php
@@ -762,6 +762,56 @@
  * @cvalue T_BAD_CHARACTER
  */
 const T_BAD_CHARACTER = UNKNOWN;
+/**
+ * @var int
+ * @cvalue T_MARKUP_NAME
+ */
+const T_MARKUP_NAME = UNKNOWN;
+/**
+ * @var int
+ * @cvalue T_MARKUP_TEXT
+ */
+const T_MARKUP_TEXT = UNKNOWN;
+/**
+ * @var int
+ * @cvalue T_MARKUP_ATTR_VALUE
+ */
+const T_MARKUP_ATTR_VALUE = UNKNOWN;
+/**
+ * @var int
+ * @cvalue T_MARKUP_COMMENT
+ */
+const T_MARKUP_COMMENT = UNKNOWN;
+/**
+ * @var int
+ * @cvalue T_MARKUP_OPEN
+ */
+const T_MARKUP_OPEN = UNKNOWN;
+/**
+ * @var int
+ * @cvalue T_MARKUP_CLOSE_OPEN
+ */
+const T_MARKUP_CLOSE_OPEN = UNKNOWN;
+/**
+ * @var int
+ * @cvalue T_MARKUP_TAG_END
+ */
+const T_MARKUP_TAG_END = UNKNOWN;
+/**
+ * @var int
+ * @cvalue T_MARKUP_SELF_CLOSE
+ */
+const T_MARKUP_SELF_CLOSE = UNKNOWN;
+/**
+ * @var int
+ * @cvalue T_MARKUP_INTERP_START
+ */
+const T_MARKUP_INTERP_START = UNKNOWN;
+/**
+ * @var int
+ * @cvalue T_MARKUP_DOCTYPE
+ */
+const T_MARKUP_DOCTYPE = UNKNOWN;
 /**
  * @var int
  * @cvalue T_PAAMAYIM_NEKUDOTAYIM
diff --git a/ext/tokenizer/tokenizer_data_arginfo.h b/ext/tokenizer/tokenizer_data_arginfo.h
index b82842ede0f1..cfe652504a00 100644
--- a/ext/tokenizer/tokenizer_data_arginfo.h
+++ b/ext/tokenizer/tokenizer_data_arginfo.h
@@ -1,5 +1,5 @@
 /* This is a generated file, edit tokenizer_data.stub.php instead.
- * Stub hash: c5235344b7c651d27c2c33c90696a418a9c96837 */
+ * Stub hash: 5f63b55a55ecb34b1e7d33d3017aa4841be2c982 */
 
 static void register_tokenizer_data_symbols(int module_number)
 {
@@ -155,5 +155,15 @@ static void register_tokenizer_data_symbols(int module_number)
 	REGISTER_LONG_CONSTANT("T_AMPERSAND_FOLLOWED_BY_VAR_OR_VARARG", T_AMPERSAND_FOLLOWED_BY_VAR_OR_VARARG, CONST_PERSISTENT);
 	REGISTER_LONG_CONSTANT("T_AMPERSAND_NOT_FOLLOWED_BY_VAR_OR_VARARG", T_AMPERSAND_NOT_FOLLOWED_BY_VAR_OR_VARARG, CONST_PERSISTENT);
 	REGISTER_LONG_CONSTANT("T_BAD_CHARACTER", T_BAD_CHARACTER, CONST_PERSISTENT);
+	REGISTER_LONG_CONSTANT("T_MARKUP_NAME", T_MARKUP_NAME, CONST_PERSISTENT);
+	REGISTER_LONG_CONSTANT("T_MARKUP_TEXT", T_MARKUP_TEXT, CONST_PERSISTENT);
+	REGISTER_LONG_CONSTANT("T_MARKUP_ATTR_VALUE", T_MARKUP_ATTR_VALUE, CONST_PERSISTENT);
+	REGISTER_LONG_CONSTANT("T_MARKUP_COMMENT", T_MARKUP_COMMENT, CONST_PERSISTENT);
+	REGISTER_LONG_CONSTANT("T_MARKUP_OPEN", T_MARKUP_OPEN, CONST_PERSISTENT);
+	REGISTER_LONG_CONSTANT("T_MARKUP_CLOSE_OPEN", T_MARKUP_CLOSE_OPEN, CONST_PERSISTENT);
+	REGISTER_LONG_CONSTANT("T_MARKUP_TAG_END", T_MARKUP_TAG_END, CONST_PERSISTENT);
+	REGISTER_LONG_CONSTANT("T_MARKUP_SELF_CLOSE", T_MARKUP_SELF_CLOSE, CONST_PERSISTENT);
+	REGISTER_LONG_CONSTANT("T_MARKUP_INTERP_START", T_MARKUP_INTERP_START, CONST_PERSISTENT);
+	REGISTER_LONG_CONSTANT("T_MARKUP_DOCTYPE", T_MARKUP_DOCTYPE, CONST_PERSISTENT);
 	REGISTER_LONG_CONSTANT("T_DOUBLE_COLON", T_PAAMAYIM_NEKUDOTAYIM, CONST_PERSISTENT);
 }
diff --git a/win32/build/config.w32 b/win32/build/config.w32
index a0f26033306f..eb4ff84ddaef 100644
--- a/win32/build/config.w32
+++ b/win32/build/config.w32
@@ -241,7 +241,7 @@ ADD_SOURCES("Zend", "zend_language_parser.c zend_language_scanner.c \
 	zend_float.c zend_string.c zend_generators.c zend_virtual_cwd.c zend_ast.c \
 	zend_inheritance.c zend_smart_str.c zend_cpuinfo.c zend_observer.c zend_system_id.c \
 	zend_enum.c zend_fibers.c zend_atomic.c zend_hrtime.c zend_frameless_function.c zend_property_hooks.c \
-	zend_lazy_objects.c zend_autoload.c");
+	zend_lazy_objects.c zend_autoload.c zend_markup.c");
 ADD_SOURCES("Zend\\Optimizer", "zend_optimizer.c pass1.c pass3.c optimize_func_calls.c block_pass.c optimize_temp_vars_5.c nop_removal.c compact_literals.c zend_cfg.c zend_dfg.c dfa_pass.c zend_ssa.c zend_inference.c zend_func_info.c zend_call_graph.c zend_dump.c escape_analysis.c compact_vars.c dce.c sccp.c scdf.c");
 
 var PHP_ASSEMBLER = PATH_PROG({