Commit 3e379b435c6 for php

commit 3e379b435c6f1ec2b1353b12123a32ad817de4a4
Author: David Carlier <devnexen@gmail.com>
Date:   Tue Nov 17 15:23:03 2026 +0000

    ext/dom: querySelector() rejects a non-ASCII leading identifier.

    Fix GH-25501

    The bundled lexbor CSS tokenizer missed the U+00B7, U+00C0 to U+00F6 and
    U+037D ident code points, swallowed a rejected code point at the end of an
    ident, and tested UTF-8 lead bytes against its ASCII name table. Backport
    the upstream fixes 3a5217afde, 70b790f828, 7e56383173 and ce777c50f2.

    Close GH-25520

diff --git a/NEWS b/NEWS
index d29b778cd7f..c8a9bdcdf05 100644
--- a/NEWS
+++ b/NEWS
@@ -53,6 +53,8 @@ PHP                                                                        NEWS
   . Fixed crash when registerNodeClass() is given a class with a constant
     expression that cannot be evaluated; registerNodeClass() now throws the
     evaluation Error instead. (Ilia Alshanetsky)
+  . Fixed bug GH-25501 (querySelector() rejects a selector whose identifier
+    starts with a non-ASCII character). (David Carlier)

 - Filter:
   . Fixed stack overflow in filter_var() and filter_var_array() with deeply
diff --git a/ext/dom/lexbor/lexbor/css/syntax/state.c b/ext/dom/lexbor/lexbor/css/syntax/state.c
index a93731e1123..5b694e9cdba 100644
--- a/ext/dom/lexbor/lexbor/css/syntax/state.c
+++ b/ext/dom/lexbor/lexbor/css/syntax/state.c
@@ -67,21 +67,13 @@
     }

 #define LXB_CSS_SYNTAX_UTF_8_UP_80_BLOCK(tkz, begin, data, end)               \
+        const lxb_char_t *_bad = data;                                        \
         lxb_codepoint_t cp = lxb_css_syntax_state_decode_utf_8_up_80(&data,   \
                                                                      end);    \
                                                                               \
         if (cp == LXB_CSS_SYNTAX_ERROR_CODEPOINT) {                           \
-            lxb_css_syntax_buffer_append_m(tkz, begin, data - begin);         \
-            /* U+FFFD REPLACEMENT CHARACTER */                                \
-            lxb_css_syntax_buffer_append_m(tkz, "\uFFFD",                     \
-                                           lxb_css_syntax_replacement_length);\
-            data += 1;                                                        \
-            begin = data;                                                     \
-        }                                                                     \
-        /* Surrogate U+D800 to U+DFFF. */                                     \
-        else if (cp >= 0xD800 && cp <= 0xDFFF) {                              \
-            lxb_css_syntax_buffer_append_m(tkz, begin,                        \
-                                           (data - begin) - 3);               \
+            /* Flush the run before the ill-formed sequence, then U+FFFD. */  \
+            lxb_css_syntax_buffer_append_m(tkz, begin, _bad - begin);         \
             /* U+FFFD REPLACEMENT CHARACTER */                                \
             lxb_css_syntax_buffer_append_m(tkz, "\uFFFD",                     \
                                            lxb_css_syntax_replacement_length);\
@@ -157,44 +149,64 @@ lxb_css_syntax_state_valid_escape(const lxb_char_t *data,
 lxb_inline bool
 lxb_css_syntax_state_non_ascii(lxb_codepoint_t cp)
 {
-    /*
-     * Actually here the comparison should be to U+D7FF.
-     * But we capture surrogate pairs, they will be further converted to 0xFFFD.
-     */
-
     /* This code is generated by the file utils/lexbor/css/syntax/non_ascii.pl */

     /* Begin */
-    if (cp <= 0x2FEF) {
-        if (cp <= 0x1FFF) {
-            if (cp >= 0x00F8 && cp < 0x037D) {
+    if (cp <= 0x2040) {
+        if (cp <= 0x00F6) {
+            if (cp >= 0x00B7 && cp <= 0x00B7) {
                 return true;
             }
-            else if (cp >= 0x037F) {
-                return true;
+            else if (cp >= 0x00C0) {
+                if (cp <= 0x00D6) {
+                    return true;
+                }
+                else if (cp >= 0x00D8) {
+                    return true;
+                }
             }
         }
-        else if (cp >= 0x2070) {
-            if (cp <= 0x218F) {
-                return true;
+        else if (cp >= 0x00F8) {
+            if (cp <= 0x1FFF) {
+                if (cp <= 0x037D) {
+                    return true;
+                }
+                else if (cp >= 0x037F) {
+                    return true;
+                }
             }
-            else if (cp >= 0x2C00) {
-                return true;
+            else if (cp >= 0x200C) {
+                if (cp <= 0x200D) {
+                    return true;
+                }
+                else if (cp >= 0x203F) {
+                    return true;
+                }
             }
         }
     }
-    else if (cp >= 0x3001) {
-        if (cp <= 0xFDCF) {
-            if (cp <= 0xDFFF) {
+    else if (cp >= 0x2070) {
+        if (cp <= 0xD7FF) {
+            if (cp <= 0x218F) {
                 return true;
             }
-            else if (cp >= 0xF900) {
-                return true;
+            else if (cp >= 0x2C00) {
+                if (cp <= 0x2FEF) {
+                    return true;
+                }
+                else if (cp >= 0x3001) {
+                    return true;
+                }
             }
         }
-        else if (cp >= 0xFDF0) {
+        else if (cp >= 0xF900) {
             if (cp <= 0xFFFD) {
-                return true;
+                if (cp <= 0xFDCF) {
+                    return true;
+                }
+                else if (cp >= 0xFDF0) {
+                    return true;
+                }
             }
             else if (cp >= 0x10000) {
                 if (cp <= 0x10FFFF) {
@@ -205,7 +217,7 @@ lxb_css_syntax_state_non_ascii(lxb_codepoint_t cp)
     }
     /* End */

-    return cp == 0x200C || cp == 0x200D || cp == 0x203F || cp == 0x2040;
+    return false;
 }

 lxb_inline bool
@@ -565,14 +577,6 @@ lxb_css_syntax_state_string(lxb_css_syntax_tokenizer_t *tkz, lxb_css_syntax_toke
                             cp = lxb_css_syntax_state_decode_utf_8_up_80(&data, end);

                             if (cp == LXB_CSS_SYNTAX_ERROR_CODEPOINT) {
-                                /* U+FFFD REPLACEMENT CHARACTER */
-                                lxb_css_syntax_buffer_append_m(tkz, "\uFFFD",
-                                                               lxb_css_syntax_replacement_length);
-                                data += 1;
-                                begin = data;
-                            }
-                            /* Surrogate U+D800 to U+DFFF. */
-                            else if (cp >= 0xD800 && cp <= 0xDFFF) {
                                 /* U+FFFD REPLACEMENT CHARACTER */
                                 lxb_css_syntax_buffer_append_m(tkz, "\uFFFD",
                                                                lxb_css_syntax_replacement_length);
@@ -629,6 +633,17 @@ lxb_css_syntax_state_hash(lxb_css_syntax_tokenizer_t *tkz,
         return lxb_css_syntax_state_delim_set(token, data - 1, '#');
     }

+    if (*data >= 0x80) {
+        begin = data;
+
+        if (lxb_css_syntax_state_start_ident_utf_8_80(&data, end)) {
+            data = begin;
+            goto hash;
+        }
+
+        return lxb_css_syntax_state_delim_set(token, begin - 1, '#');
+    }
+
     if (lxb_css_syntax_res_name_map[*data] == 0x00) {
         if (*data == 0x00) {
             goto hash;
@@ -1202,6 +1217,7 @@ lxb_css_syntax_state_consume_ident(lxb_css_syntax_tokenizer_t *tkz,
         else {
             LXB_CSS_SYNTAX_UTF_8_UP_80_BLOCK(tkz, begin, data, end)
             else if (!lxb_css_syntax_state_non_ascii(cp)) {
+                data = _bad;
                 break;
             }
         }
@@ -1630,7 +1646,13 @@ lxb_css_syntax_state_escaped(lxb_css_syntax_tokenizer_t *tkz,

         if (lexbor_str_res_map_hex[*data] == 0xFF) {
             if (count == 0) {
-                cp = (lxb_codepoint_t) *data++;
+                if (*data < 0x80) {
+                    cp = (lxb_codepoint_t) *data++;
+                }
+                else {
+                    cp = lxb_css_syntax_state_decode_utf_8_up_80(&data, end);
+                }
+
                 goto done;
             }

@@ -1770,98 +1792,61 @@ static lxb_codepoint_t
 lxb_css_syntax_state_decode_utf_8_up_80(const lxb_char_t **data,
                                         const lxb_char_t *end)
 {
-    lxb_char_t ch;
+    lxb_char_t ch, lower, upper;
+    unsigned needed;
     const lxb_char_t *p;
     lxb_codepoint_t cp;

+    /*
+     * WHATWG UTF-8 decoder: https://encoding.spec.whatwg.org/#utf-8-decoder
+     */
+
     p = *data;
-    ch = *p;
+    ch = *p++;

     if (ch <= 0xDF) {
-        if (ch < 0xC2 || p + 1 >= end) {
+        if (ch < 0xC2) {
+            *data = p;
             return LXB_CSS_SYNTAX_ERROR_CODEPOINT;
         }

+        needed = 1;
+        lower = 0x80;
+        upper = 0xBF;
         cp = ch & 0x1F;
-
-        if (p[1] < 0x80 || p[1] > 0xBF) {
-            return LXB_CSS_SYNTAX_ERROR_CODEPOINT;
-        }
-
-        cp = (cp << 6) | (p[1] & 0x3F);
-
-        *data += 2;
     }
-    else if (ch < 0xF0) {
+    else if (ch <= 0xEF) {
+        needed = 2;
+        lower = (ch == 0xE0) ? 0xA0 : 0x80;
+        upper = (ch == 0xED) ? 0x9F : 0xBF;
         cp = ch & 0x0F;
-
-        if (p + 2 >= end) {
-            return LXB_CSS_SYNTAX_ERROR_CODEPOINT;
-        }
-
-        if (ch == 0xE0) {
-            if (p[1] < 0xA0 || p[1] > 0xBF) {
-                return LXB_CSS_SYNTAX_ERROR_CODEPOINT;
-            }
-        }
-
-        /*
-         * We returning surrogate pair!
-         */
-/*
-        else if (ch == 0xED) {
-            if (p[1] < 0x80 || p[1] > 0x9F) {
-                return LXB_CSS_SYNTAX_ERROR_CODEPOINT;
-            }
-        }
- */
-        else if (p[1] < 0x80 || p[1] > 0xBF) {
-            return LXB_CSS_SYNTAX_ERROR_CODEPOINT;
-        }
-
-        if (p[2] < 0x80 || p[2] > 0xBF) {
-            return LXB_CSS_SYNTAX_ERROR_CODEPOINT;
-        }
-
-        cp = (cp << 6) | (p[1] & 0x3F);
-        cp = (cp << 6) | (p[2] & 0x3F);
-
-        *data += 3;
     }
-    else if (ch < 0xF5) {
+    else if (ch <= 0xF4) {
+        needed = 3;
+        lower = (ch == 0xF0) ? 0x90 : 0x80;
+        upper = (ch == 0xF4) ? 0x8F : 0xBF;
         cp = ch & 0x07;
+    }
+    else {
+        /* 0xF5..0xFF: an invalid lead byte. */
+        *data = p;
+        return LXB_CSS_SYNTAX_ERROR_CODEPOINT;
+    }

-        if (p + 3 >= end) {
-            return LXB_CSS_SYNTAX_ERROR_CODEPOINT;
-        }
-
-        if (ch == 0xF0) {
-            if (p[1] < 0x90 || p[1] > 0xBF) {
-                return LXB_CSS_SYNTAX_ERROR_CODEPOINT;
-            }
-        }
-        else if (ch == 0xF4) {
-            if (p[1] < 0x80 || p[1] > 0x8F) {
-                return LXB_CSS_SYNTAX_ERROR_CODEPOINT;
-            }
-        }
-        else if (p[1] < 0x80 || p[1] > 0xBF) {
-            return LXB_CSS_SYNTAX_ERROR_CODEPOINT;
-        }
-
-        if ((p[2] < 0x80 || p[2] > 0xBF) || (p[3] < 0x80 || p[3] > 0xBF)) {
+    do {
+        if (p >= end || *p < lower || *p > upper) {
+            *data = p;
             return LXB_CSS_SYNTAX_ERROR_CODEPOINT;
         }

-        cp = (cp << 6) | (p[1] & 0x3F);
-        cp = (cp << 6) | (p[2] & 0x3F);
-        cp = (cp << 6) | (p[3] & 0x3F);
+        cp = (cp << 6) | (*p++ & 0x3F);

-        *data += 4;
-    }
-    else {
-        return LXB_CSS_SYNTAX_ERROR_CODEPOINT;
+        lower = 0x80;
+        upper = 0xBF;
     }
+    while (--needed != 0);
+
+    *data = p;

     return cp;
 }
diff --git a/ext/dom/lexbor/patches/0001-Expose-line-and-column-information-for-use-in-PHP.patch b/ext/dom/lexbor/patches/0001-Expose-line-and-column-information-for-use-in-PHP.patch
index 04136b29f58..9aec14cca5d 100644
--- a/ext/dom/lexbor/patches/0001-Expose-line-and-column-information-for-use-in-PHP.patch
+++ b/ext/dom/lexbor/patches/0001-Expose-line-and-column-information-for-use-in-PHP.patch
@@ -1,7 +1,7 @@
 From 0000000000000000000000000000000000000000 Mon Sep 17 00:00:00 2001
 From: Niels Dossche <7771979+nielsdos@users.noreply.github.com>
 Date: Sat, 26 Aug 2023 15:08:59 +0200
-Subject: [PATCH 1/8] Expose line and column information for use in PHP
+Subject: [PATCH 01/12] Expose line and column information for use in PHP

 ---
  source/lexbor/dom/interfaces/node.h  |  2 ++
diff --git a/ext/dom/lexbor/patches/0002-Track-implied-added-nodes-for-options-use-in-PHP.patch b/ext/dom/lexbor/patches/0002-Track-implied-added-nodes-for-options-use-in-PHP.patch
index 615655d7f2e..9f4da029446 100644
--- a/ext/dom/lexbor/patches/0002-Track-implied-added-nodes-for-options-use-in-PHP.patch
+++ b/ext/dom/lexbor/patches/0002-Track-implied-added-nodes-for-options-use-in-PHP.patch
@@ -1,7 +1,7 @@
 From 0000000000000000000000000000000000000000 Mon Sep 17 00:00:00 2001
 From: Niels Dossche <7771979+nielsdos@users.noreply.github.com>
 Date: Mon, 14 Aug 2023 20:18:51 +0200
-Subject: [PATCH 2/8] Track implied added nodes for options use in PHP
+Subject: [PATCH 02/12] Track implied added nodes for options use in PHP

 ---
  source/lexbor/html/tree.h                            | 3 +++
diff --git a/ext/dom/lexbor/patches/0003-Patch-utilities-and-data-structure-to-be-able-to-gen.patch b/ext/dom/lexbor/patches/0003-Patch-utilities-and-data-structure-to-be-able-to-gen.patch
index 73c5afa19e1..fe7068d9bda 100644
--- a/ext/dom/lexbor/patches/0003-Patch-utilities-and-data-structure-to-be-able-to-gen.patch
+++ b/ext/dom/lexbor/patches/0003-Patch-utilities-and-data-structure-to-be-able-to-gen.patch
@@ -1,8 +1,8 @@
 From 0000000000000000000000000000000000000000 Mon Sep 17 00:00:00 2001
 From: Niels Dossche <7771979+nielsdos@users.noreply.github.com>
 Date: Thu, 24 Aug 2023 22:57:48 +0200
-Subject: [PATCH 3/8] Patch utilities and data structure to be able to generate
- smaller lookup tables
+Subject: [PATCH 03/12] Patch utilities and data structure to be able to
+ generate smaller lookup tables

 Changed the generation script to check if everything fits in 32-bits.
 And change the actual field types to 32-bits. This decreases the hash
diff --git a/ext/dom/lexbor/patches/0004-Remove-unused-upper-case-tag-static-data.patch b/ext/dom/lexbor/patches/0004-Remove-unused-upper-case-tag-static-data.patch
index cc0a65a7cd5..35482388531 100644
--- a/ext/dom/lexbor/patches/0004-Remove-unused-upper-case-tag-static-data.patch
+++ b/ext/dom/lexbor/patches/0004-Remove-unused-upper-case-tag-static-data.patch
@@ -1,7 +1,7 @@
 From 0000000000000000000000000000000000000000 Mon Sep 17 00:00:00 2001
 From: Niels Dossche <7771979+nielsdos@users.noreply.github.com>
 Date: Wed, 29 Nov 2023 21:26:47 +0100
-Subject: [PATCH 4/8] Remove unused upper case tag static data
+Subject: [PATCH 04/12] Remove unused upper case tag static data

 ---
  source/lexbor/tag/res.h | 2 ++
diff --git a/ext/dom/lexbor/patches/0005-Shrink-size-of-static-binary-search-tree.patch b/ext/dom/lexbor/patches/0005-Shrink-size-of-static-binary-search-tree.patch
index b84120bf6c8..8e9b9524104 100644
--- a/ext/dom/lexbor/patches/0005-Shrink-size-of-static-binary-search-tree.patch
+++ b/ext/dom/lexbor/patches/0005-Shrink-size-of-static-binary-search-tree.patch
@@ -1,7 +1,7 @@
 From 0000000000000000000000000000000000000000 Mon Sep 17 00:00:00 2001
 From: Niels Dossche <7771979+nielsdos@users.noreply.github.com>
 Date: Wed, 29 Nov 2023 21:29:31 +0100
-Subject: [PATCH 5/8] Shrink size of static binary search tree
+Subject: [PATCH 05/12] Shrink size of static binary search tree

 This also makes it more efficient on the data cache.
 ---
diff --git a/ext/dom/lexbor/patches/0006-Patch-out-unused-CSS-style-code.patch b/ext/dom/lexbor/patches/0006-Patch-out-unused-CSS-style-code.patch
index 196a5a8a62d..0f4e4cd8661 100644
--- a/ext/dom/lexbor/patches/0006-Patch-out-unused-CSS-style-code.patch
+++ b/ext/dom/lexbor/patches/0006-Patch-out-unused-CSS-style-code.patch
@@ -1,7 +1,7 @@
 From 0000000000000000000000000000000000000000 Mon Sep 17 00:00:00 2001
 From: Niels Dossche <7771979+nielsdos@users.noreply.github.com>
 Date: Sun, 7 Jan 2024 21:59:28 +0100
-Subject: [PATCH 6/8] Patch out unused CSS style code
+Subject: [PATCH 06/12] Patch out unused CSS style code

 ---
  source/lexbor/css/rule.h | 2 ++
diff --git a/ext/dom/lexbor/patches/0007-CSS-fixed-heap-buffer-overflow-in-lexbor-contains-pa.patch b/ext/dom/lexbor/patches/0007-CSS-fixed-heap-buffer-overflow-in-lexbor-contains-pa.patch
index cc689714b6c..3d0bb9ecdc0 100644
--- a/ext/dom/lexbor/patches/0007-CSS-fixed-heap-buffer-overflow-in-lexbor-contains-pa.patch
+++ b/ext/dom/lexbor/patches/0007-CSS-fixed-heap-buffer-overflow-in-lexbor-contains-pa.patch
@@ -1,7 +1,7 @@
 From 0000000000000000000000000000000000000000 Mon Sep 17 00:00:00 2001
 From: Alexander Borisov <lex.borisov@gmail.com>
 Date: Fri, 5 Jun 2026 22:34:23 +0300
-Subject: [PATCH 7/8] CSS: fixed heap buffer overflow in :lexbor-contains()
+Subject: [PATCH 07/12] CSS: fixed heap buffer overflow in :lexbor-contains()
  parsing.

 The contains string buffer was allocated by the size of the string
diff --git a/ext/dom/lexbor/patches/0008-Encoding-fixed-buffer-overflows-in-malformed-decode-.patch b/ext/dom/lexbor/patches/0008-Encoding-fixed-buffer-overflows-in-malformed-decode-.patch
index 352ebd95b2c..cec351fb639 100644
--- a/ext/dom/lexbor/patches/0008-Encoding-fixed-buffer-overflows-in-malformed-decode-.patch
+++ b/ext/dom/lexbor/patches/0008-Encoding-fixed-buffer-overflows-in-malformed-decode-.patch
@@ -1,7 +1,7 @@
 From 0000000000000000000000000000000000000000 Mon Sep 17 00:00:00 2001
 From: Alexander Borisov <lex.borisov@gmail.com>
 Date: Wed, 10 Jun 2026 19:50:10 +0300
-Subject: [PATCH 8/8] Encoding: fixed buffer overflows in malformed decode
+Subject: [PATCH 08/12] Encoding: fixed buffer overflows in malformed decode
  replay.

 Fixed out-of-bounds writes in buffering decoders when replacement output
diff --git a/ext/dom/lexbor/patches/0009-CSS-Syntax-fixed-non-ASCII-ident-code-point-ranges.patch b/ext/dom/lexbor/patches/0009-CSS-Syntax-fixed-non-ASCII-ident-code-point-ranges.patch
new file mode 100644
index 00000000000..9a2059fab5c
--- /dev/null
+++ b/ext/dom/lexbor/patches/0009-CSS-Syntax-fixed-non-ASCII-ident-code-point-ranges.patch
@@ -0,0 +1,78 @@
+From 0000000000000000000000000000000000000000 Mon Sep 17 00:00:00 2001
+From: Alexander Borisov <lex.borisov@gmail.com>
+Date: Sat, 20 Jun 2026 15:39:44 +0400
+Subject: [PATCH 09/12] CSS::Syntax: fixed non-ASCII ident code point ranges.
+
+By specification https://drafts.csswg.org/css-syntax/#non-ascii-ident-code-point.
+
+Per report from Jon Surrell (@sirreal).
+
+This relates to #382 issue on GitHub.
+---
+ source/lexbor/css/syntax/state.c | 41 ++++++++++++++++++++++----------
+ 1 file changed, 28 insertions(+), 13 deletions(-)
+
+diff --git a/source/lexbor/css/syntax/state.c b/source/lexbor/css/syntax/state.c
+index a93731e..a011c5a 100644
+--- a/source/lexbor/css/syntax/state.c
++++ b/source/lexbor/css/syntax/state.c
+@@ -165,31 +165,46 @@ lxb_css_syntax_state_non_ascii(lxb_codepoint_t cp)
+     /* This code is generated by the file utils/lexbor/css/syntax/non_ascii.pl */
+
+     /* Begin */
+-    if (cp <= 0x2FEF) {
+-        if (cp <= 0x1FFF) {
+-            if (cp >= 0x00F8 && cp < 0x037D) {
++    if (cp <= 0x218F) {
++        if (cp <= 0x00F6) {
++            if (cp >= 0x00B7 && cp <= 0x00B7) {
+                 return true;
+             }
+-            else if (cp >= 0x037F) {
+-                return true;
++            else if (cp >= 0x00C0) {
++                if (cp <= 0x00D6) {
++                    return true;
++                }
++                else if (cp >= 0x00D8) {
++                    return true;
++                }
+             }
+         }
+-        else if (cp >= 0x2070) {
+-            if (cp <= 0x218F) {
++        else if (cp >= 0x00F8) {
++            if (cp <= 0x037D) {
+                 return true;
+             }
+-            else if (cp >= 0x2C00) {
+-                return true;
++            else if (cp >= 0x037F) {
++                if (cp <= 0x1FFF) {
++                    return true;
++                }
++                else if (cp >= 0x2070) {
++                    return true;
++                }
+             }
+         }
+     }
+-    else if (cp >= 0x3001) {
++    else if (cp >= 0x2C00) {
+         if (cp <= 0xFDCF) {
+-            if (cp <= 0xDFFF) {
++            if (cp <= 0x2FEF) {
+                 return true;
+             }
+-            else if (cp >= 0xF900) {
+-                return true;
++            else if (cp >= 0x3001) {
++                if (cp <= 0xDFFF) {
++                    return true;
++                }
++                else if (cp >= 0xF900) {
++                    return true;
++                }
+             }
+         }
+         else if (cp >= 0xFDF0) {
diff --git a/ext/dom/lexbor/patches/0010-iCSS-Syntax-fixed-U-FFFD-replacement-boundaries-for-.patch b/ext/dom/lexbor/patches/0010-iCSS-Syntax-fixed-U-FFFD-replacement-boundaries-for-.patch
new file mode 100644
index 00000000000..7306fd5e4d7
--- /dev/null
+++ b/ext/dom/lexbor/patches/0010-iCSS-Syntax-fixed-U-FFFD-replacement-boundaries-for-.patch
@@ -0,0 +1,201 @@
+From 0000000000000000000000000000000000000000 Mon Sep 17 00:00:00 2001
+From: Alexander Borisov <lex.borisov@gmail.com>
+Date: Wed, 8 Jul 2026 20:10:47 +0300
+Subject: [PATCH 10/12] iCSS::Syntax: fixed U+FFFD replacement boundaries for
+ UTF-8.
+
+The tokenizer replaced ill-formed UTF-8 with U+FFFD at boundaries that do
+not match the specification and browsers. A truncated sequence with valid
+continuation bytes (E2 8C) produced two U+FFFD instead of one, and a UTF-8
+encoded surrogate (ED A0 80) produced one U+FFFD instead of three.
+
+By specification, each maximal subpart of an ill-formed subsequence must
+be replaced with a single U+FFFD:
+https://drafts.csswg.org/css-syntax/#input-byte-stream
+https://encoding.spec.whatwg.org/#utf-8-decoder
+
+Per report from Jon Surrell (@sirreal).
+
+This closes #390 issue on GitHub.
+---
+ source/lexbor/css/syntax/state.c | 129 +++++++++----------------------
+ 1 file changed, 38 insertions(+), 91 deletions(-)
+
+diff --git a/source/lexbor/css/syntax/state.c b/source/lexbor/css/syntax/state.c
+index a011c5a..abcf930 100644
+--- a/source/lexbor/css/syntax/state.c
++++ b/source/lexbor/css/syntax/state.c
+@@ -67,21 +67,13 @@
+     }
+
+ #define LXB_CSS_SYNTAX_UTF_8_UP_80_BLOCK(tkz, begin, data, end)               \
++        const lxb_char_t *_bad = data;                                        \
+         lxb_codepoint_t cp = lxb_css_syntax_state_decode_utf_8_up_80(&data,   \
+                                                                      end);    \
+                                                                               \
+         if (cp == LXB_CSS_SYNTAX_ERROR_CODEPOINT) {                           \
+-            lxb_css_syntax_buffer_append_m(tkz, begin, data - begin);         \
+-            /* U+FFFD REPLACEMENT CHARACTER */                                \
+-            lxb_css_syntax_buffer_append_m(tkz, "\uFFFD",                     \
+-                                           lxb_css_syntax_replacement_length);\
+-            data += 1;                                                        \
+-            begin = data;                                                     \
+-        }                                                                     \
+-        /* Surrogate U+D800 to U+DFFF. */                                     \
+-        else if (cp >= 0xD800 && cp <= 0xDFFF) {                              \
+-            lxb_css_syntax_buffer_append_m(tkz, begin,                        \
+-                                           (data - begin) - 3);               \
++            /* Flush the run before the ill-formed sequence, then U+FFFD. */  \
++            lxb_css_syntax_buffer_append_m(tkz, begin, _bad - begin);         \
+             /* U+FFFD REPLACEMENT CHARACTER */                                \
+             lxb_css_syntax_buffer_append_m(tkz, "\uFFFD",                     \
+                                            lxb_css_syntax_replacement_length);\
+@@ -580,14 +572,6 @@ lxb_css_syntax_state_string(lxb_css_syntax_tokenizer_t *tkz, lxb_css_syntax_toke
+                             cp = lxb_css_syntax_state_decode_utf_8_up_80(&data, end);
+
+                             if (cp == LXB_CSS_SYNTAX_ERROR_CODEPOINT) {
+-                                /* U+FFFD REPLACEMENT CHARACTER */
+-                                lxb_css_syntax_buffer_append_m(tkz, "\uFFFD",
+-                                                               lxb_css_syntax_replacement_length);
+-                                data += 1;
+-                                begin = data;
+-                            }
+-                            /* Surrogate U+D800 to U+DFFF. */
+-                            else if (cp >= 0xD800 && cp <= 0xDFFF) {
+                                 /* U+FFFD REPLACEMENT CHARACTER */
+                                 lxb_css_syntax_buffer_append_m(tkz, "\uFFFD",
+                                                                lxb_css_syntax_replacement_length);
+@@ -1785,98 +1769,61 @@ static lxb_codepoint_t
+ lxb_css_syntax_state_decode_utf_8_up_80(const lxb_char_t **data,
+                                         const lxb_char_t *end)
+ {
+-    lxb_char_t ch;
++    lxb_char_t ch, lower, upper;
++    unsigned needed;
+     const lxb_char_t *p;
+     lxb_codepoint_t cp;
+
++    /*
++     * WHATWG UTF-8 decoder: https://encoding.spec.whatwg.org/#utf-8-decoder
++     */
++
+     p = *data;
+-    ch = *p;
++    ch = *p++;
+
+     if (ch <= 0xDF) {
+-        if (ch < 0xC2 || p + 1 >= end) {
++        if (ch < 0xC2) {
++            *data = p;
+             return LXB_CSS_SYNTAX_ERROR_CODEPOINT;
+         }
+
++        needed = 1;
++        lower = 0x80;
++        upper = 0xBF;
+         cp = ch & 0x1F;
+-
+-        if (p[1] < 0x80 || p[1] > 0xBF) {
+-            return LXB_CSS_SYNTAX_ERROR_CODEPOINT;
+-        }
+-
+-        cp = (cp << 6) | (p[1] & 0x3F);
+-
+-        *data += 2;
+     }
+-    else if (ch < 0xF0) {
++    else if (ch <= 0xEF) {
++        needed = 2;
++        lower = (ch == 0xE0) ? 0xA0 : 0x80;
++        upper = (ch == 0xED) ? 0x9F : 0xBF;
+         cp = ch & 0x0F;
+-
+-        if (p + 2 >= end) {
+-            return LXB_CSS_SYNTAX_ERROR_CODEPOINT;
+-        }
+-
+-        if (ch == 0xE0) {
+-            if (p[1] < 0xA0 || p[1] > 0xBF) {
+-                return LXB_CSS_SYNTAX_ERROR_CODEPOINT;
+-            }
+-        }
+-
+-        /*
+-         * We returning surrogate pair!
+-         */
+-/*
+-        else if (ch == 0xED) {
+-            if (p[1] < 0x80 || p[1] > 0x9F) {
+-                return LXB_CSS_SYNTAX_ERROR_CODEPOINT;
+-            }
+-        }
+- */
+-        else if (p[1] < 0x80 || p[1] > 0xBF) {
+-            return LXB_CSS_SYNTAX_ERROR_CODEPOINT;
+-        }
+-
+-        if (p[2] < 0x80 || p[2] > 0xBF) {
+-            return LXB_CSS_SYNTAX_ERROR_CODEPOINT;
+-        }
+-
+-        cp = (cp << 6) | (p[1] & 0x3F);
+-        cp = (cp << 6) | (p[2] & 0x3F);
+-
+-        *data += 3;
+     }
+-    else if (ch < 0xF5) {
++    else if (ch <= 0xF4) {
++        needed = 3;
++        lower = (ch == 0xF0) ? 0x90 : 0x80;
++        upper = (ch == 0xF4) ? 0x8F : 0xBF;
+         cp = ch & 0x07;
++    }
++    else {
++        /* 0xF5..0xFF: an invalid lead byte. */
++        *data = p;
++        return LXB_CSS_SYNTAX_ERROR_CODEPOINT;
++    }
+
+-        if (p + 3 >= end) {
+-            return LXB_CSS_SYNTAX_ERROR_CODEPOINT;
+-        }
+-
+-        if (ch == 0xF0) {
+-            if (p[1] < 0x90 || p[1] > 0xBF) {
+-                return LXB_CSS_SYNTAX_ERROR_CODEPOINT;
+-            }
+-        }
+-        else if (ch == 0xF4) {
+-            if (p[1] < 0x80 || p[1] > 0x8F) {
+-                return LXB_CSS_SYNTAX_ERROR_CODEPOINT;
+-            }
+-        }
+-        else if (p[1] < 0x80 || p[1] > 0xBF) {
+-            return LXB_CSS_SYNTAX_ERROR_CODEPOINT;
+-        }
+-
+-        if ((p[2] < 0x80 || p[2] > 0xBF) || (p[3] < 0x80 || p[3] > 0xBF)) {
++    do {
++        if (p >= end || *p < lower || *p > upper) {
++            *data = p;
+             return LXB_CSS_SYNTAX_ERROR_CODEPOINT;
+         }
+
+-        cp = (cp << 6) | (p[1] & 0x3F);
+-        cp = (cp << 6) | (p[2] & 0x3F);
+-        cp = (cp << 6) | (p[3] & 0x3F);
++        cp = (cp << 6) | (*p++ & 0x3F);
+
+-        *data += 4;
+-    }
+-    else {
+-        return LXB_CSS_SYNTAX_ERROR_CODEPOINT;
++        lower = 0x80;
++        upper = 0xBF;
+     }
++    while (--needed != 0);
++
++    *data = p;
+
+     return cp;
+ }
diff --git a/ext/dom/lexbor/patches/0011-CSS-Syntax-fixed-UTF-8-escapes-in-ident-sequences.patch b/ext/dom/lexbor/patches/0011-CSS-Syntax-fixed-UTF-8-escapes-in-ident-sequences.patch
new file mode 100644
index 00000000000..d95a8003121
--- /dev/null
+++ b/ext/dom/lexbor/patches/0011-CSS-Syntax-fixed-UTF-8-escapes-in-ident-sequences.patch
@@ -0,0 +1,60 @@
+From 0000000000000000000000000000000000000000 Mon Sep 17 00:00:00 2001
+From: Alexander Borisov <lex.borisov@gmail.com>
+Date: Thu, 9 Jul 2026 23:24:05 +0300
+Subject: [PATCH 11/12] CSS::Syntax: fixed UTF-8 escapes in ident sequences.
+MIME-Version: 1.0
+Content-Type: text/plain; charset=UTF-8
+Content-Transfer-Encoding: 8bit
+
+Non-hex escapes consumed only the first byte of a UTF-8 sequence and used it
+as a code point. Because of this, "a\é" became "aÃ�" instead of "aé".
+The same issue affected unquoted URL tokens.
+---
+ source/lexbor/css/syntax/state.c | 20 +++++++++++++++++++-
+ 1 file changed, 19 insertions(+), 1 deletion(-)
+
+diff --git a/source/lexbor/css/syntax/state.c b/source/lexbor/css/syntax/state.c
+index abcf930..a1db76a 100644
+--- a/source/lexbor/css/syntax/state.c
++++ b/source/lexbor/css/syntax/state.c
+@@ -628,6 +628,17 @@ lxb_css_syntax_state_hash(lxb_css_syntax_tokenizer_t *tkz,
+         return lxb_css_syntax_state_delim_set(token, data - 1, '#');
+     }
+
++    if (*data >= 0x80) {
++        begin = data;
++
++        if (lxb_css_syntax_state_start_ident_utf_8_80(&data, end)) {
++            data = begin;
++            goto hash;
++        }
++
++        return lxb_css_syntax_state_delim_set(token, begin - 1, '#');
++    }
++
+     if (lxb_css_syntax_res_name_map[*data] == 0x00) {
+         if (*data == 0x00) {
+             goto hash;
+@@ -1201,6 +1212,7 @@ lxb_css_syntax_state_consume_ident(lxb_css_syntax_tokenizer_t *tkz,
+         else {
+             LXB_CSS_SYNTAX_UTF_8_UP_80_BLOCK(tkz, begin, data, end)
+             else if (!lxb_css_syntax_state_non_ascii(cp)) {
++                data = _bad;
+                 break;
+             }
+         }
+@@ -1629,7 +1641,13 @@ lxb_css_syntax_state_escaped(lxb_css_syntax_tokenizer_t *tkz,
+
+         if (lexbor_str_res_map_hex[*data] == 0xFF) {
+             if (count == 0) {
+-                cp = (lxb_codepoint_t) *data++;
++                if (*data < 0x80) {
++                    cp = (lxb_codepoint_t) *data++;
++                }
++                else {
++                    cp = lxb_css_syntax_state_decode_utf_8_up_80(&data, end);
++                }
++
+                 goto done;
+             }
+
diff --git a/ext/dom/lexbor/patches/0012-CSS-Syntax-fixed-non-ASCII-ident-code-points.patch b/ext/dom/lexbor/patches/0012-CSS-Syntax-fixed-non-ASCII-ident-code-points.patch
new file mode 100644
index 00000000000..bfdfef77b60
--- /dev/null
+++ b/ext/dom/lexbor/patches/0012-CSS-Syntax-fixed-non-ASCII-ident-code-points.patch
@@ -0,0 +1,102 @@
+From 0000000000000000000000000000000000000000 Mon Sep 17 00:00:00 2001
+From: Alexander Borisov <lex.borisov@gmail.com>
+Date: Fri, 10 Jul 2026 00:39:54 +0300
+Subject: [PATCH 12/12] CSS::Syntax: fixed non-ASCII ident code points.
+
+Updated generated non-ASCII ident ranges to match CSS Syntax:
+included U+200C/U+200D and U+203F/U+2040, and stopped the
+U+3001 range at U+D7FF to exclude surrogate code points.
+---
+ source/lexbor/css/syntax/state.c | 45 ++++++++++++++++++--------------
+ 1 file changed, 25 insertions(+), 20 deletions(-)
+
+diff --git a/source/lexbor/css/syntax/state.c b/source/lexbor/css/syntax/state.c
+index a1db76a..5b694e9 100644
+--- a/source/lexbor/css/syntax/state.c
++++ b/source/lexbor/css/syntax/state.c
+@@ -149,15 +149,10 @@ lxb_css_syntax_state_valid_escape(const lxb_char_t *data,
+ lxb_inline bool
+ lxb_css_syntax_state_non_ascii(lxb_codepoint_t cp)
+ {
+-    /*
+-     * Actually here the comparison should be to U+D7FF.
+-     * But we capture surrogate pairs, they will be further converted to 0xFFFD.
+-     */
+-
+     /* This code is generated by the file utils/lexbor/css/syntax/non_ascii.pl */
+
+     /* Begin */
+-    if (cp <= 0x218F) {
++    if (cp <= 0x2040) {
+         if (cp <= 0x00F6) {
+             if (cp >= 0x00B7 && cp <= 0x00B7) {
+                 return true;
+@@ -172,36 +167,46 @@ lxb_css_syntax_state_non_ascii(lxb_codepoint_t cp)
+             }
+         }
+         else if (cp >= 0x00F8) {
+-            if (cp <= 0x037D) {
+-                return true;
++            if (cp <= 0x1FFF) {
++                if (cp <= 0x037D) {
++                    return true;
++                }
++                else if (cp >= 0x037F) {
++                    return true;
++                }
+             }
+-            else if (cp >= 0x037F) {
+-                if (cp <= 0x1FFF) {
++            else if (cp >= 0x200C) {
++                if (cp <= 0x200D) {
+                     return true;
+                 }
+-                else if (cp >= 0x2070) {
++                else if (cp >= 0x203F) {
+                     return true;
+                 }
+             }
+         }
+     }
+-    else if (cp >= 0x2C00) {
+-        if (cp <= 0xFDCF) {
+-            if (cp <= 0x2FEF) {
++    else if (cp >= 0x2070) {
++        if (cp <= 0xD7FF) {
++            if (cp <= 0x218F) {
+                 return true;
+             }
+-            else if (cp >= 0x3001) {
+-                if (cp <= 0xDFFF) {
++            else if (cp >= 0x2C00) {
++                if (cp <= 0x2FEF) {
+                     return true;
+                 }
+-                else if (cp >= 0xF900) {
++                else if (cp >= 0x3001) {
+                     return true;
+                 }
+             }
+         }
+-        else if (cp >= 0xFDF0) {
++        else if (cp >= 0xF900) {
+             if (cp <= 0xFFFD) {
+-                return true;
++                if (cp <= 0xFDCF) {
++                    return true;
++                }
++                else if (cp >= 0xFDF0) {
++                    return true;
++                }
+             }
+             else if (cp >= 0x10000) {
+                 if (cp <= 0x10FFFF) {
+@@ -212,7 +217,7 @@ lxb_css_syntax_state_non_ascii(lxb_codepoint_t cp)
+     }
+     /* End */
+
+-    return cp == 0x200C || cp == 0x200D || cp == 0x203F || cp == 0x2040;
++    return false;
+ }
+
+ lxb_inline bool
diff --git a/ext/dom/tests/modern/css_selectors/gh25501.phpt b/ext/dom/tests/modern/css_selectors/gh25501.phpt
new file mode 100644
index 00000000000..5b740bf9ba5
--- /dev/null
+++ b/ext/dom/tests/modern/css_selectors/gh25501.phpt
@@ -0,0 +1,53 @@
+--TEST--
+GH-25501 (querySelector() rejects a selector whose identifier starts with a non-ASCII character)
+--CREDITS--
+phcorp
+--EXTENSIONS--
+dom
+--FILE--
+<?php
+
+$dom = Dom\HTMLDocument::createFromString(
+    '<p id="été">a</p><p class="élan">b</p><p class="café">c</p><p class="cafés">d</p>'
+    . '<p class="Über">e</p><p class="ͽx">f</p><p class="a×">g</p>',
+    LIBXML_NOERROR
+);
+
+$selectors = [
+    '#\e9 t\e9',
+    '#été',
+    'p#été',
+    '[id=été]',
+    '.élan',
+    '.café',
+    '.cafés',
+    '.Über',
+    '.ͽx',
+    '.a×',
+    '#×',
+    '.÷x',
+];
+
+foreach ($selectors as $selector) {
+    echo $selector, ': ';
+    try {
+        var_dump($dom->querySelector($selector)?->textContent);
+    } catch (DOMException $e) {
+        echo $e::class, ': ', $e->getMessage(), PHP_EOL;
+    }
+}
+
+?>
+--EXPECT--
+#\e9 t\e9: string(1) "a"
+#été: string(1) "a"
+p#été: string(1) "a"
+[id=été]: string(1) "a"
+.élan: string(1) "b"
+.café: string(1) "c"
+.cafés: string(1) "d"
+.Über: string(1) "e"
+.ͽx: string(1) "f"
+.a×: DOMException: Invalid selector (Selectors. Unexpected token: ×)
+#×: DOMException: Invalid selector (Selectors. Unexpected token: #)
+.÷x: DOMException: Invalid selector (Selectors. Unexpected token: ÷)