Backtestsjsouprun-20261006-181938#2594

Issue #2594 Merged fix PR #2595 Run 6 Oct 2026 · run-20261006-181938 jhy/jsoup

Name normalization can trim control characters and apply Unicode case folding

Worse

The merged fix was judged better than our patch.

In this judgment, Patch A = our agent, Patch B = the merged fix.

The issue's central example is a parsed attribute name like `data-x\u0001` being trimmed down to `data-x` and then treated as equal to it.

Patch A misses that parser path. It changes `Normalizer.normalize` and replaces `equalsIgnoreCase`/`lowerCase` with ASCII versions in many places. However, it leaves `name = name.trim()` in `Token.Tag.newAttribute`, so `<p data-x\u0001=1 data-x=2>` still drops the control character during tokenizing. The two names then collapse into one. Patch A's tests only exercise the case through the API (`attributes().put`, `new Attribute`), so they never catch this gap.

Patch B removes that trim. It updates `handlesControlCodeInAttributeName` so parsed control-character names are kept and repaired only at serialization. Its new `attributesKeepIdentityAndSourceRanges` test checks that a parsed `DATA-X\u0001` and `data-x` stay distinct, including source ranges.

Patch B also covers paths Patch A leaves alone:
- It stops trimming the `annotation-xml` encoding value, which the spec compares exactly with ASCII case-insensitivity, and tests this.
- It stops trimming in XML end-tag closing and doctype name normalization.
- In the tokeniser, it compares end tags against the start tag's normalized name.
- It replaces `normalize` in `QueryParser` and `Evaluator` with explicit ASCII-trim plus ASCII-lowercase.
- It applies ASCII folding to `Tag` construction.

Patch B's tests are broader and more targeted: buffer-boundary end-tag matching, multi-locale `Normalizer` checks, XML exact-name closing, Safelist, selectors and source ranges.

Patch B carries some extra risk. It removes the already-deprecated `normalize(String, boolean)` and `ParseSettings.normalName`, and adds an exclusion for `org.jsoup.internal` to the API compatibility check in `pom.xml`. These are internal APIs flagged for removal, so the risk is modest.

On correctness for the issue's main scenario, Patch B is clearly better.

The judge saw only the two patches, labelled A and B in random order, with issue links and version numbers removed. The reasoning above is shown verbatim.

Solve

10m 10s

Wall-clock time in the container

Full test suite

No new failures

2,228 passed · 0 skipped · 2,228 total

Contamination audit

Clean

No sign the agent saw the real fix

Patch size

363vs 454 merged

Changed lines, ours vs merged

Currently some parser paths use Normalizer.normalize(...) for names that require narrower rules.

The current implementation trims with String.trim() and lowercases with Unicode rules. That can remove control characters from accepted tag and attribute names, and can make non-ASCII names compare as equal to ASCII names. The HTML5 spec has tag and attribute names as ASCII case insensitive.

For example, these should not equal:

"data-x\u0001"
"data-x"

"K"
"k"

"ſ"
"s"

HTML name comparisons should use ASCII-only case folding. XML parsing should preserve exact names unless the configured parse settings request ASCII folding.

This affects tag and attribute identity, duplicate detection, selector matching, and contextual parser choices.

The two patches

Our patch+321 −42
src/main/java/org/jsoup/helper/DataUtil.javaindex c5c4e43f..caca4a1e 100644@@ -295,7 +295,7 @@ public final class DataUtil {                     if (comment.isXmlDeclaration())                         decl = comment.asXmlDeclaration();                 }-                if (decl != null && decl.name().equalsIgnoreCase("xml")) {+                if (decl != null && Normalizer.asciiEqualsIgnoreCase(decl.name(), "xml")) {                     foundCharset = decl.attr("encoding");                 }             }src/main/java/org/jsoup/helper/W3CDom.javaindex f1a369d4..32e8ce95 100644@@ -1,6 +1,7 @@ package org.jsoup.helper;  import org.jsoup.internal.NamespaceBindings;+import org.jsoup.internal.Normalizer; import org.jsoup.internal.StringUtil; import org.jsoup.nodes.Attribute; import org.jsoup.nodes.Attributes;@@ -139,7 +140,7 @@ public class W3CDom {                 if (!StringUtil.isBlank(doctype.getSystemId()))                     transformer.setOutputProperty(OutputKeys.DOCTYPE_SYSTEM, doctype.getSystemId());                     // handle <!doctype html> for legacy dom.-                else if (doctype.getName().equalsIgnoreCase("html")+                else if (Normalizer.asciiEqualsIgnoreCase(doctype.getName(), "html")                     && StringUtil.isBlank(doctype.getPublicId())                     && StringUtil.isBlank(doctype.getSystemId()))                     transformer.setOutputProperty(OutputKeys.DOCTYPE_SYSTEM, "about:legacy-compat");@@ -432,7 +433,7 @@ public class W3CDom {          // XmlDeclaration also represents <!name ...> nodes; XML declarations are reserved by the W3C DOM.         private void appendProcessingInstruction(org.jsoup.nodes.XmlDeclaration source) {-            if (!source.outerHtml().startsWith("<?") || source.name().equalsIgnoreCase("xml")) return;+            if (!source.outerHtml().startsWith("<?") || Normalizer.asciiEqualsIgnoreCase(source.name(), "xml")) return;             try {                 append(doc.createProcessingInstruction(source.name(), source.getWholeDeclaration()), source);             } catch (DOMException ignored) {src/main/java/org/jsoup/internal/Normalizer.javaindex 8d51f69d..4d981ac5 100644@@ -15,9 +15,82 @@ public final class Normalizer {         return input != null ? input.toLowerCase(Locale.ROOT) : "";     } -    /** Lower-cases and trims the input string. */+    /**+     Lower-cases and trims the input string, for use with names (tag and attribute names, selector keys). Only ASCII+     upper-case letters are folded, and only HTML ASCII whitespace (space, tab, LF, FF, CR) is trimmed; other control+     characters and non-ASCII characters are preserved.+     */     public static String normalize(final String input) {-        return lowerCase(input).trim();+        return asciiLowerCase(trimAsciiWhitespace(input));+    }++    /**+     Lower-cases only the ASCII letters {@code A-Z} in the input, per the HTML spec's "ASCII lowercase". Non-ASCII+     characters (e.g. the Kelvin sign {@code U+212A}) are left as-is, so they will not compare equal to ASCII names.+     @param input string to lower-case; null returns an empty string+     @return the ASCII lower-cased string+     */+    public static String asciiLowerCase(final String input) {+        if (input == null) return "";+        final int len = input.length();+        int i = 0;+        while (i < len) {+            char c = input.charAt(i);+            if (c >= 'A' && c <= 'Z') break;+            i++;+        }+        if (i == len) return input;+        char[] chars = input.toCharArray();+        for (; i < len; i++) {+            char c = chars[i];+            if (c >= 'A' && c <= 'Z') chars[i] = (char) (c + ('a' - 'A'));+        }+        return new String(chars);+    }++    /**+     Removes leading and trailing HTML ASCII whitespace (space, tab, LF, FF, CR). Unlike {@link String#trim()}, other+     control characters are preserved.+     @param input string to trim; null returns an empty string+     @return the trimmed string+     */+    public static String trimAsciiWhitespace(final String input) {+        if (input == null) return "";+        int start = 0;+        int end = input.length();+        while (start < end && StringUtil.isWhitespace(input.charAt(start))) start++;+        while (end > start && StringUtil.isWhitespace(input.charAt(end - 1))) end--;+        return (start == 0 && end == input.length()) ? input : input.substring(start, end);+    }++    /**+     Tests if two strings are equal under ASCII case-insensitive comparison (only {@code A-Z} / {@code a-z} fold).+     */+    public static boolean asciiEqualsIgnoreCase(final String a, final String b) {+        if (a == null || b == null) return a == b;+        return a.length() == b.length() && asciiRegionMatchesIgnoreCase(a, 0, b, 0, a.length());+    }++    /**+     Tests if two string regions are equal under ASCII case-insensitive comparison.+     */+    public static boolean asciiRegionMatchesIgnoreCase(final String a, int aOffset, final String b, int bOffset, int len) {+        if (aOffset < 0 || bOffset < 0 || len < 0+            || aOffset > a.length() - len || bOffset > b.length() - len)+            return false;+        for (int i = 0; i < len; i++) {+            if (!asciiCharEqualsIgnoreCase(a.charAt(aOffset + i), b.charAt(bOffset + i)))+                return false;+        }+        return true;+    }++    /** Tests if two chars are equal under ASCII case-insensitive comparison. */+    public static boolean asciiCharEqualsIgnoreCase(char a, char b) {+        if (a == b) return true;+        if (a >= 'A' && a <= 'Z') a = (char) (a + ('a' - 'A'));+        if (b >= 'A' && b <= 'Z') b = (char) (b + ('a' - 'A'));+        return a == b;     }      /**src/main/java/org/jsoup/nodes/Attribute.javaindex cbea8238..86d5da26 100644@@ -47,7 +47,7 @@ public class Attribute implements Map.Entry<String, String>, Cloneable  {      * @see #createFromEncoded*/     public Attribute(String key, @Nullable String val, @Nullable Attributes parent) {         Validate.notNull(key);-        key = key.trim();+        key = Normalizer.trimAsciiWhitespace(key);         Validate.notEmpty(key); // trimming could potentially make empty, so validate here         this.key = key;         this.val = val;@@ -69,7 +69,7 @@ public class Attribute implements Map.Entry<String, String>, Cloneable  {      */     public void setKey(String key) {         Validate.notNull(key);-        key = key.trim();+        key = Normalizer.trimAsciiWhitespace(key);         Validate.notEmpty(key); // trimming could potentially make empty, so validate here         if (parent != null) {             int i = parent.indexOfKey(this.key);@@ -315,14 +315,14 @@ public class Attribute implements Map.Entry<String, String>, Cloneable  {     // collapse unknown foo=null, known checked=null, checked="", checked=checked; write out others     protected static boolean shouldCollapseAttribute(final String key, @Nullable final String val, final Document.OutputSettings out) {         return (out.syntax() == Syntax.html &&-                (val == null || (val.isEmpty() || val.equalsIgnoreCase(key)) && Attribute.isBooleanAttribute(key)));+                (val == null || (val.isEmpty() || Normalizer.asciiEqualsIgnoreCase(val, key)) && Attribute.isBooleanAttribute(key)));     }      /**      * Checks if this attribute name is defined as a boolean attribute in HTML5      */     public static boolean isBooleanAttribute(final String key) {-        return Arrays.binarySearch(booleanAttributes, Normalizer.lowerCase(key)) >= 0;+        return Arrays.binarySearch(booleanAttributes, Normalizer.asciiLowerCase(key)) >= 0;     }      @Overridesrc/main/java/org/jsoup/nodes/Attributes.javaindex acaf8ba7..c3797ae6 100644@@ -23,7 +23,8 @@ import java.util.NoSuchElementException; import java.util.Objects; import java.util.Set; -import static org.jsoup.internal.Normalizer.lowerCase;+import static org.jsoup.internal.Normalizer.asciiEqualsIgnoreCase;+import static org.jsoup.internal.Normalizer.asciiLowerCase; import static org.jsoup.nodes.Document.OutputSettings.Syntax.xml; import static org.jsoup.nodes.Range.AttributeRange.UntrackedAttr; @@ -116,7 +117,7 @@ public class Attributes implements Iterable<Attribute>, Cloneable {     private int indexOfKeyIgnoreCase(String key) {         Validate.notNull(key);         for (int i = 0; i < size; i++) {-            if (key.equalsIgnoreCase(keys[i]))+            if (asciiEqualsIgnoreCase(key, keys[i]))                 return i;         }         return NotFound;@@ -598,12 +599,12 @@ public class Attributes implements Iterable<Attribute>, Cloneable {      /** Normalizes a key for the output syntax's case sensitivity. */     private static String comparisonKey(String key, Syntax syntax) {-        return syntax == xml ? key : lowerCase(key);+        return syntax == xml ? key : asciiLowerCase(key);     }      /** Compares keys with the requested case sensitivity. */     private static boolean keysEqual(String first, String second, boolean caseSensitive) {-        return caseSensitive ? first.equals(second) : first.equalsIgnoreCase(second);+        return caseSensitive ? first.equals(second) : asciiEqualsIgnoreCase(first, second);     }      @Override@@ -683,7 +684,7 @@ public class Attributes implements Iterable<Attribute>, Cloneable {             String key = keys[i];             assert key != null;             if (!isInternalKey(key))-                keys[i] = lowerCase(key);+                keys[i] = asciiLowerCase(key);         }     } src/main/java/org/jsoup/nodes/Element.javaindex b91e8e60..23b57d3c 100644@@ -1,6 +1,7 @@ package org.jsoup.nodes;  import org.jsoup.helper.Validate;+import org.jsoup.internal.Normalizer; import org.jsoup.internal.QuietAppendable; import org.jsoup.helper.Regex; import org.jsoup.internal.StringUtil;@@ -1321,7 +1322,7 @@ public class Element extends Node implements Iterable<Element> {      */     public Elements getElementsByAttribute(String key) {         Validate.notEmpty(key);-        key = key.trim();+        key = Normalizer.trimAsciiWhitespace(key);          return Collector.collect(new Evaluator.Attribute(key), this);     }@@ -1334,7 +1335,7 @@ public class Element extends Node implements Iterable<Element> {      */     public Elements getElementsByAttributeStarting(String keyPrefix) {         Validate.notEmpty(keyPrefix);-        keyPrefix = keyPrefix.trim();+        keyPrefix = Normalizer.trimAsciiWhitespace(keyPrefix);          return Collector.collect(new Evaluator.AttributeStarting(keyPrefix), this);     }src/main/java/org/jsoup/parser/CharacterReader.javaindex 28378a35..54da8ac8 100644@@ -2,6 +2,7 @@ package org.jsoup.parser;  import org.jsoup.helper.Validate; import org.jsoup.internal.LineMap;+import org.jsoup.internal.Normalizer; import org.jsoup.internal.SoftPool; import org.jsoup.internal.StringUtil; import org.jspecify.annotations.Nullable;@@ -598,11 +599,7 @@ public final class CharacterReader implements AutoCloseable {         for (int offset = 0; offset < seq.length(); offset++) {             char scan = seq.charAt(offset);             char target = charBuf[start + offset];-            if (scan == target) continue;--            scan = Character.toUpperCase(scan);-            target = Character.toUpperCase(target);-            if (scan != target) return false;+            if (!Normalizer.asciiCharEqualsIgnoreCase(scan, target)) return false;         }         return true;     }src/main/java/org/jsoup/parser/HtmlTreeBuilderState.javaindex c3cfe33c..803b8d99 100644@@ -1,6 +1,7 @@ package org.jsoup.parser;  import org.jsoup.helper.Validate;+import org.jsoup.internal.Normalizer; import org.jsoup.internal.StringUtil; import org.jsoup.nodes.Attribute; import org.jsoup.nodes.Attributes;@@ -37,7 +38,7 @@ enum HtmlTreeBuilderState {                 tb.getDocument().appendChild(doctype);                 tb.onNodeInserted(doctype);                 // todo: quirk state check on more doctype ids, if deemed useful (most are ancient legacy and presumably irrelevant)-                if (d.isForceQuirks() || !doctype.name().equals("html") || doctype.publicId().equalsIgnoreCase("HTML"))+                if (d.isForceQuirks() || !doctype.name().equals("html") || Normalizer.asciiEqualsIgnoreCase(doctype.publicId(), "HTML"))                     tb.getDocument().quirksMode(Document.QuirksMode.quirks);                 tb.transition(BeforeHtml);             } else {@@ -422,7 +423,7 @@ enum HtmlTreeBuilderState {                 case "input":                     tb.reconstructFormattingElements();                     el = tb.insertEmptyElementFor(startTag);-                    if (!el.attr("type").equalsIgnoreCase("hidden"))+                    if (!Normalizer.asciiEqualsIgnoreCase(el.attr("type"), "hidden"))                         tb.framesetOk(false);                     break;                 case "hr":@@ -1024,7 +1025,7 @@ enum HtmlTreeBuilderState {                 } else if (name.equals("noscript")) {                     tb.startNoscript(startTag);                 } else if (name.equals("input")) {-                    if (!(startTag.hasAttributes() && startTag.attributes.get("type").equalsIgnoreCase("hidden"))) {+                    if (!(startTag.hasAttributes() && Normalizer.asciiEqualsIgnoreCase(startTag.attributes.get("type"), "hidden"))) {                         return anythingElse(t, tb);                     } else {                         tb.insertEmptyElementFor(startTag);src/main/java/org/jsoup/parser/ParseSettings.javaindex b31e5f8c..aff2b071 100644@@ -3,8 +3,9 @@ package org.jsoup.parser; import org.jsoup.nodes.Attributes; import org.jspecify.annotations.Nullable; -import static org.jsoup.internal.Normalizer.lowerCase;+import static org.jsoup.internal.Normalizer.asciiLowerCase; import static org.jsoup.internal.Normalizer.normalize;+import static org.jsoup.internal.Normalizer.trimAsciiWhitespace;  /**  * Controls parser case settings, to optionally preserve tag and/or attribute name case.@@ -59,9 +60,9 @@ public class ParseSettings {      * Normalizes a tag name according to the case preservation setting.      */     public String normalizeTag(String name) {-        name = name.trim();+        name = trimAsciiWhitespace(name);         if (!preserveTagCase)-            name = lowerCase(name);+            name = asciiLowerCase(name);         return name;     } @@ -69,9 +70,9 @@ public class ParseSettings {      * Normalizes an attribute according to the case preservation setting.      */     public String normalizeAttribute(String name) {-        name = name.trim();+        name = trimAsciiWhitespace(name);         if (!preserveAttributeCase)-            name = lowerCase(name);+            name = asciiLowerCase(name);         return name;     } @@ -81,7 +82,7 @@ public class ParseSettings {         }     } -    /** Returns the normal name that a Tag will have (trimmed and lower-cased) */+    /** Returns the normal name that a Tag will have (ASCII whitespace trimmed and ASCII lower-cased) */     static String normalName(String name) {         return normalize(name);     }src/main/java/org/jsoup/parser/TagSet.javaindex a55ef55d..2c77b592 100644@@ -1,6 +1,7 @@ package org.jsoup.parser;  import org.jsoup.helper.Validate;+import org.jsoup.internal.Normalizer; import org.jsoup.internal.SharedConstants; import org.jspecify.annotations.Nullable; @@ -137,7 +138,7 @@ public class TagSet {     Tag valueOf(String tagName, @Nullable String normalName, String namespace, boolean preserveTagCase) {         Validate.notNull(tagName);         Validate.notNull(namespace);-        if (normalName == null) tagName = tagName.trim(); // public API input; tokenizer names are already delimited+        if (normalName == null) tagName = Normalizer.trimAsciiWhitespace(tagName); // public API input; tokenizer names are already delimited         Validate.notEmpty(tagName);         Tag tag = get(tagName, namespace);         if (tag != null) return tag;src/main/java/org/jsoup/parser/Token.javaindex 44e58638..756546b4 100644@@ -9,7 +9,7 @@ import org.jspecify.annotations.Nullable; import java.util.Arrays; import java.util.Objects; -import static org.jsoup.internal.Normalizer.lowerCase;+import static org.jsoup.internal.Normalizer.asciiLowerCase;  /**  * Parse tokens for the Tokeniser.@@ -301,7 +301,7 @@ abstract class Token {          final Tag name(String name) {             tagName.set(name);-            normalName = lowerCase(tagName.value());+            normalName = asciiLowerCase(tagName.value());             return this;         } @@ -314,7 +314,7 @@ abstract class Token {             // might have null chars - need to replace with null replacement character             append = append.replace(TokeniserState.nullChar, Tokeniser.replacementChar);             tagName.append(append);-            normalName = lowerCase(tagName.value());+            normalName = asciiLowerCase(tagName.value());         }          final void appendTagName(char append) {@@ -389,7 +389,7 @@ abstract class Token {         StartTag nameAttr(String name, Attributes attributes) {             this.tagName.set(name);             this.attributes = attributes;-            normalName = lowerCase(name);+            normalName = asciiLowerCase(name);             return this;         } src/main/java/org/jsoup/parser/Tokeniser.javaindex 91605a89..70c1eb31 100644@@ -1,6 +1,7 @@ package org.jsoup.parser;  import org.jsoup.helper.Validate;+import org.jsoup.internal.Normalizer; import org.jsoup.internal.StringUtil; import org.jsoup.nodes.Document; import org.jsoup.nodes.Entities;@@ -268,7 +269,7 @@ final class Tokeniser {      /** Test if the pending end tag matches the last emitted start tag. */     boolean isAppropriateEndTagToken() {-        return lastStartTag != null && tagPending.name().equalsIgnoreCase(lastStartTag);+        return lastStartTag != null && Normalizer.asciiEqualsIgnoreCase(tagPending.name(), lastStartTag);     }      /** Test if appending the character would keep the pending end tag a prefix of the expected name. */@@ -278,7 +279,7 @@ final class Tokeniser {         String candidate = tagPending.normalName();         int length = candidate.length();         return length < lastStartTag.length()-            && lastStartTag.regionMatches(true, 0, candidate, 0, length)+            && Normalizer.asciiRegionMatchesIgnoreCase(lastStartTag, 0, candidate, 0, length)             && lastStartTag.charAt(length) == next;     } src/main/java/org/jsoup/safety/Safelist.javaindex 13fb5abc..48c3867e 100644@@ -256,7 +256,7 @@ public class Safelist {          for (String tagName : tags) {             Validate.notEmpty(tagName);-            Validate.isFalse(tagName.equalsIgnoreCase("noscript"),+            Validate.isFalse(Normalizer.asciiEqualsIgnoreCase(tagName, "noscript"),                 "noscript is unsupported in Safelists, due to incompatibilities between parsers with and without script-mode enabled");             tagNames.add(TagName.valueOf(tagName));         }@@ -632,7 +632,7 @@ public class Safelist {         }          static TagName valueOf(String value) {-            return new TagName(Normalizer.lowerCase(value));+            return new TagName(Normalizer.asciiLowerCase(value));         }     } @@ -642,7 +642,7 @@ public class Safelist {         }          static AttributeKey valueOf(String value) {-            return new AttributeKey(Normalizer.lowerCase(value));+            return new AttributeKey(Normalizer.asciiLowerCase(value));         }     } src/main/java/org/jsoup/select/Evaluator.javaindex f3b6a353..c5141ff8 100644@@ -16,6 +16,7 @@ import java.util.List; import java.util.function.Predicate; import java.util.regex.Pattern; +import static org.jsoup.internal.Normalizer.asciiLowerCase; import static org.jsoup.internal.Normalizer.lowerCase; import static org.jsoup.internal.Normalizer.normalize; import static org.jsoup.internal.StringUtil.normaliseWhitespace;@@ -237,14 +238,14 @@ public abstract class Evaluator {          public AttributeStarting(String keyPrefix) {             Validate.notNull(keyPrefix); // OK to be empty - will find elements with any attributes-            this.keyPrefix = lowerCase(keyPrefix);+            this.keyPrefix = asciiLowerCase(keyPrefix);         }          @Override         public boolean matches(Element root, Element element) {             List<org.jsoup.nodes.Attribute> values = element.attributes().asList();             for (org.jsoup.nodes.Attribute attribute : values) {-                if (lowerCase(attribute.getKey()).startsWith(keyPrefix))+                if (asciiLowerCase(attribute.getKey()).startsWith(keyPrefix))                     return true;             }             return false;src/test/java/org/jsoup/internal/NormalizerTest.javanew file mode 100644index 00000000..0a2a8c3b@@ -0,0 +1,51 @@+package org.jsoup.internal;++import org.junit.jupiter.api.Test;++import static org.junit.jupiter.api.Assertions.*;++public class NormalizerTest {++    @Test void normalizeOnlyTrimsAsciiWhitespaceAndFoldsAscii() {+        assertEquals("data-x", Normalizer.normalize(" \t\n\f\rDATA-X \r\n"));+        assertEquals("data-x\u0001", Normalizer.normalize("Data-X\u0001"));+        assertNotEquals(Normalizer.normalize("data-x"), Normalizer.normalize("data-x\u0001"));+        assertEquals("\u0001x", Normalizer.normalize("\u0001X"));+        assertEquals("K", Normalizer.normalize("K")); // Kelvin sign is not folded to k+        assertEquals("ſ", Normalizer.normalize("ſ")); // long s+        assertEquals("İ", Normalizer.normalize("İ")); // dotted capital I+        assertEquals("", Normalizer.normalize(null));+    }++    @Test void asciiLowerCase() {+        assertEquals("abc-xyz09", Normalizer.asciiLowerCase("AbC-XyZ09"));+        assertEquals("Ä", Normalizer.asciiLowerCase("Ä"));+        String lower = "already";+        assertSame(lower, Normalizer.asciiLowerCase(lower));+        assertEquals("", Normalizer.asciiLowerCase(null));+    }++    @Test void trimAsciiWhitespace() {+        assertEquals("a b", Normalizer.trimAsciiWhitespace(" \ta b\n"));+        assertEquals("\u0001a\u0002", Normalizer.trimAsciiWhitespace(" \u0001a\u0002 "));+        assertEquals("\u000Ba", Normalizer.trimAsciiWhitespace("\u000Ba")); // vertical tab is not HTML whitespace+        assertEquals("", Normalizer.trimAsciiWhitespace("  "));+    }++    @Test void asciiEqualsIgnoreCase() {+        assertTrue(Normalizer.asciiEqualsIgnoreCase("Data-X", "data-x"));+        assertFalse(Normalizer.asciiEqualsIgnoreCase("data-x\u0001", "data-x"));+        assertFalse(Normalizer.asciiEqualsIgnoreCase("K", "k"));+        assertFalse(Normalizer.asciiEqualsIgnoreCase("ſ", "s"));+        assertFalse(Normalizer.asciiEqualsIgnoreCase("ı", "i")); // dotless i+        assertFalse(Normalizer.asciiEqualsIgnoreCase("a", "ab"));+        assertTrue(Normalizer.asciiEqualsIgnoreCase(null, null));+        assertFalse(Normalizer.asciiEqualsIgnoreCase("a", null));+    }++    @Test void asciiRegionMatchesIgnoreCase() {+        assertTrue(Normalizer.asciiRegionMatchesIgnoreCase("SCRIPT", 0, "scr", 0, 3));+        assertFalse(Normalizer.asciiRegionMatchesIgnoreCase("SCRIPT", 0, "ſcr", 0, 3));+        assertFalse(Normalizer.asciiRegionMatchesIgnoreCase("ab", 1, "bc", 0, 2)); // out of bounds+    }+}src/test/java/org/jsoup/parser/AsciiNameFoldingTest.javanew file mode 100644index 00000000..6fbb184a@@ -0,0 +1,150 @@+package org.jsoup.parser;++import org.jsoup.Jsoup;+import org.jsoup.nodes.Attribute;+import org.jsoup.nodes.Document;+import org.jsoup.nodes.DocumentType;+import org.jsoup.nodes.Element;+import org.jsoup.safety.Safelist;+import org.junit.jupiter.api.Test;++import static org.junit.jupiter.api.Assertions.*;++/**+ Tag and attribute names are ASCII case-insensitive in HTML: only A-Z fold, and only ASCII whitespace is trimmed.+ Control characters and non-ASCII characters must not be dropped or folded into ASCII names.+ */+public class AsciiNameFoldingTest {+    private static final String Kelvin = "K"; // lower-cases to 'k' under Unicode rules+    private static final String LongS = "ſ";  // upper-cases to 'S' under Unicode rules+    private static final String DotlessI = "ı"; // upper-cases to 'I' under Unicode rules++    @Test void controlCharAttributeNameIsDistinctOnceAccepted() {+        // names via the API keep control chars, and must not match the ASCII name+        Document doc = Jsoup.parse("<div data-x=2></div>");+        Element div = doc.expectFirst("div");+        div.attributes().put("data-x\u0001", "1");+        assertEquals(2, div.attributesSize());+        assertEquals("1", div.attr("data-x\u0001"));+        assertEquals("2", div.attr("data-x"));+        assertEquals(1, doc.select("[data-x]").size());+        div.removeAttr("data-x");+        assertFalse(div.hasAttr("data-x"));+        assertTrue(div.hasAttr("data-x\u0001"));+    }++    @Test void nonAsciiAttributeNamesAreDistinctFromAscii() {+        Document doc = Jsoup.parse("<div " + Kelvin + "=1 k=2 " + LongS + "=3 s=4></div>");+        Element div = doc.expectFirst("div");+        assertEquals(4, div.attributesSize());+        assertEquals("1", div.attr(Kelvin));+        assertEquals("2", div.attr("k"));+        assertEquals("3", div.attr(LongS));+        assertEquals("4", div.attr("s"));+        assertEquals("4", div.attr("S"));++        Element only = Jsoup.parse("<p " + LongS + "=1 " + Kelvin + "=2>").expectFirst("p");+        assertFalse(only.hasAttr("s"));+        assertFalse(only.hasAttr("k"));+        assertEquals("", only.attr("s"));+        assertEquals(LongS + "=\"1\" " + Kelvin + "=\"2\"", only.attributes().html().trim());+    }++    @Test void nonAsciiTagNameIsNotFoldedToAscii() {+        Document doc = Jsoup.parse("<x" + Kelvin + ">One</x" + Kelvin + "><xk>Two</xk><XK>Three</XK>");+        Element kelvin = doc.expectFirst("body").child(0);+        assertEquals("x" + Kelvin, kelvin.normalName());+        assertEquals("x" + Kelvin, kelvin.tagName());+        assertEquals("One", kelvin.text());+        assertEquals(2, doc.select("xk").size());+        assertEquals("Two Three", doc.select("XK").text());+        assertEquals(2, doc.getElementsByTag("xK").size());+        assertNotEquals(Tag.valueOf("x" + Kelvin), Tag.valueOf("xk"));+        assertEquals("x" + Kelvin, Tag.valueOf("X" + Kelvin).normalName());+    }++    @Test void selectorAttributeKeysUseAsciiFolding() {+        Document doc = Jsoup.parse("<div " + Kelvin + "=1>A</div><div K=2>B</div>");+        assertEquals("B", doc.select("[k]").text());+        assertEquals("B", doc.select("[K]").text());+        assertEquals("B", doc.select("[k=2]").text());+        assertEquals("B", doc.select("[^k]").text());+        assertEquals(1, doc.getElementsByAttribute("k").size());+        assertEquals(1, doc.getElementsByAttributeStarting("k").size());+    }++    @Test void rawTextEndTagRequiresAsciiMatch() {+        Document doc = Jsoup.parse("<style>a</" + LongS + "tyle>b</style><title>x</t" + DotlessI + "tle>y</title>");+        assertEquals("a</" + LongS + "tyle>b", doc.expectFirst("style").data());+        assertEquals("x</t" + DotlessI + "tle>y", doc.expectFirst("title").text());+    }++    @Test void doctypeKeywordsRequireAsciiMatch() {+        Document doc = Jsoup.parse("<!DOCTYPE html " + LongS + "Y" + LongS + "TEM \"about:legacy-compat\"><p>");+        DocumentType doctype = doc.documentType();+        assertNotNull(doctype);+        assertEquals("", doctype.systemId());++        Document ascii = Jsoup.parse("<!DOCTYPE html sYsTeM \"about:legacy-compat\"><p>");+        assertEquals("about:legacy-compat", ascii.documentType().systemId());+    }++    @Test void hiddenInputTypeInTableRequiresAsciiMatch() {+        Document doc = Jsoup.parse("<table><input type=\"h" + DotlessI + "dden\"><tr><td>x</td></tr></table>");+        Element input = doc.expectFirst("input");+        assertEquals("body", input.parent().normalName()); // foster parented, not kept in table++        Document hidden = Jsoup.parse("<table><input type=\"HIDDEN\"><tr><td>x</td></tr></table>");+        assertEquals("table", hidden.expectFirst("input").parent().normalName());+    }++    @Test void apiAttributeKeysKeepControlChars() {+        assertEquals("data-x\u0001", new Attribute(" data-x\u0001 ", "v").getKey());+        Attribute attr = new Attribute("a", "v");+        attr.setKey("b\u0002");+        assertEquals("b\u0002", attr.getKey());++        Element el = new Element("div");+        el.attr("data-x\u0001", "1");+        el.attr("data-x", "2");+        assertEquals(2, el.attributesSize());+        assertEquals("1", el.attr("data-x\u0001"));+        assertEquals("2", el.attr("data-x"));+    }++    @Test void parseSettingsNormalizeWithAsciiRules() {+        ParseSettings settings = ParseSettings.htmlDefault;+        assertEquals("data-x\u0001", settings.normalizeAttribute(" DATA-X\u0001\n"));+        assertEquals(Kelvin, settings.normalizeAttribute(Kelvin));+        assertEquals(Kelvin + "bd", settings.normalizeTag(Kelvin + "BD"));+        assertEquals("K\u0001", ParseSettings.preserveCase.normalizeTag("\tK\u0001 "));+    }++    @Test void xmlPreservesExactNames() {+        Document doc = Jsoup.parse("<A " + Kelvin + "=1 k=2 K=3>x</A>", "", Parser.xmlParser());+        Element a = doc.expectFirst("A");+        assertEquals("A", a.tagName());+        assertEquals(3, a.attributesSize());+        assertEquals("1", a.attributes().get(Kelvin));+        assertEquals("2", a.attributes().get("k"));+        assertEquals("3", a.attributes().get("K"));+    }++    @Test void xmlWithAsciiFoldingSettings() {+        Parser parser = Parser.xmlParser().settings(ParseSettings.htmlDefault);+        Document doc = Jsoup.parse("<A " + Kelvin + "=1 k=2 K=3>x</a>", "", parser);+        Element a = doc.expectFirst("a");+        assertEquals("a", a.tagName());+        assertEquals(2, a.attributesSize()); // k and K fold together; Kelvin stays distinct+        assertEquals("1", a.attr(Kelvin));+        assertEquals("2", a.attr("k"));+        assertEquals("x", a.text());+    }++    @Test void safelistNamesUseAsciiFolding() {+        assertEquals("x", Jsoup.clean("<k>x</k>", new Safelist().addTags(Kelvin)));+        assertEquals("<k>x</k>", Jsoup.clean("<k>x</k>", new Safelist().addTags("K")));+        assertEquals("<b>x</b>", Jsoup.clean("<b k=1>x</b>", new Safelist().addTags("b").addAttributes("b", Kelvin)));+        assertEquals("<b k=\"1\">x</b>", Jsoup.clean("<b k=1>x</b>", new Safelist().addTags("b").addAttributes("b", "K")));+    }+} 
Merged fix · PR #2595+358 −96
CHANGES.mdindex 6361c5fc..5f5e8222 100644@@ -1,5 +1,10 @@ # jsoup Changelog +## 1.24.1 (Pending)++### Bug Fixes+* Standardized parser normalization of tag and attribute names so that HTML comparisons use ASCII-only case folding, and accepted control characters are preserved, aligning name handling to the HTML and XML specs. [#2594](https://github.com/jhy/jsoup/issues/2594)+ ## 1.23.2 (2026-Aug-26)  ### Improvementspom.xmlindex f495fdba..7ade97ec 100644@@ -318,7 +318,7 @@             <dependency>               <groupId>org.jsoup</groupId>               <artifactId>jsoup</artifactId>-              <version>1.23.1</version>+              <version>1.23.2</version>               <type>jar</type>             </dependency>           </oldVersion>@@ -327,6 +327,10 @@             <onlyModified>false</onlyModified>             <breakBuildOnBinaryIncompatibleModifications>true</breakBuildOnBinaryIncompatibleModifications>             <breakBuildOnSourceIncompatibleModifications>true</breakBuildOnSourceIncompatibleModifications>+            <excludes>+              <!-- Internal APIs are explicitly unsupported and may change between releases. -->+              <exclude>org.jsoup.internal.*</exclude>+            </excludes>             <overrideCompatibilityChangeParameters>               <!-- allows new default and move to default methods. compatible as long as existing binaries aren't making calls via reflection. if so, they need to catch errors anyway. -->               <overrideCompatibilityChangeParameter>src/main/java/org/jsoup/internal/Normalizer.javaindex 8d51f69d..1961501e 100644@@ -2,32 +2,49 @@ package org.jsoup.internal;  import org.jsoup.nodes.Attribute; import org.jsoup.nodes.Document;+import org.jspecify.annotations.Nullable;  import java.util.Locale;  /**  * Util methods for normalizing strings. Jsoup internal use only, please don't depend on this API.+ * <p>ASCII case conversion changes only A-Z; Unicode conversion uses {@link Locale#ROOT}.+ * Neither trims, and the string lowercasing methods return an empty string for null input.</p>  */ public final class Normalizer { -    /** Drops the input string to lower case. */-    public static String lowerCase(final String input) {+    /** Lowercases Unicode text. */+    public static String lowerCase(final @Nullable String input) {         return input != null ? input.toLowerCase(Locale.ROOT) : "";     } -    /** Lower-cases and trims the input string. */-    public static String normalize(final String input) {-        return lowerCase(input).trim();+    /** Lowercases ASCII letters. */+    public static String asciiLowerCase(final @Nullable String input) {+        if (input == null) return "";+        char[] chars = null;+        for (int i = 0; i < input.length(); i++) {+            char c = input.charAt(i);+            char lower = asciiLowerCase(c);+            if (c != lower) {+                if (chars == null) chars = input.toCharArray(); // set up on first change+                chars[i] = lower;+            }+        }+        return chars == null ? input : new String(chars);     } -    /**-     If a string literal, just lower case the string; otherwise lower-case and trim.-     @deprecated internal helper; replace with {@link #lowerCase(String)} for no-trim, or {@link #normalize(String)} for trim + lowercase.-     Will be removed in jsoup 1.24.1.-     */-    @Deprecated-    public static String normalize(final String input, boolean isStringLiteral) {-        return isStringLiteral ? lowerCase(input) : normalize(input);+    /** Lowercases an ASCII letter. */+    public static char asciiLowerCase(char c) {+        return c >= 'A' && c <= 'Z' ? (char) (c + ('a' - 'A')) : c;+    }++    /** Compares strings ignoring ASCII case. */+    public static boolean equalsIgnoreAsciiCase(String first, @Nullable String second) {+        if (second == null || first.length() != second.length()) return false;+        for (int i = 0; i < first.length(); i++) {+            if (asciiLowerCase(first.charAt(i)) != asciiLowerCase(second.charAt(i))) return false;+        }+        return true;     }      /**src/main/java/org/jsoup/internal/StringUtil.javaindex 35d9bbb5..a6abbca0 100644@@ -188,6 +188,14 @@ public final class StringUtil {         return true;     } +    /** Trims leading and trailing ASCII whitespace. */+    public static String trimAsciiWhitespace(String input) {+        int start = 0, end = input.length();+        while (start < end && isWhitespace(input.charAt(start))) start++;+        while (end > start && isWhitespace(input.charAt(end - 1))) end--;+        return input.substring(start, end);+    }+     /**      * Tests if a code point is "whitespace" as defined in the HTML spec. Used for output HTML.      * @param c code point to testsrc/main/java/org/jsoup/nodes/Attribute.javaindex cbea8238..51060544 100644@@ -15,7 +15,8 @@ import java.util.Objects; import java.util.regex.Pattern;  /**- A single key + value attribute. (Only used for presentation.)+ Represents one attribute as a key/value pair.+ Keys preserve case and are trimmed of surrounding ASCII whitespace when created or changed.  */ public class Attribute implements Map.Entry<String, String>, Cloneable  {     private static final String[] booleanAttributes = {@@ -31,7 +32,7 @@ public class Attribute implements Map.Entry<String, String>, Cloneable  {      /**      * Create a new attribute from unencoded (raw) key and value.-     * @param key attribute key; case is preserved.+     * @param key attribute key      * @param value attribute value (may be null)      * @see #createFromEncoded      */@@ -41,13 +42,13 @@ public class Attribute implements Map.Entry<String, String>, Cloneable  {      /**      * Create a new attribute from unencoded (raw) key and value.-     * @param key attribute key; case is preserved.+     * @param key attribute key      * @param val attribute value (may be null)      * @param parent the containing Attributes (this Attribute is not automatically added to said Attributes)      * @see #createFromEncoded*/     public Attribute(String key, @Nullable String val, @Nullable Attributes parent) {         Validate.notNull(key);-        key = key.trim();+        key = StringUtil.trimAsciiWhitespace(key);         Validate.notEmpty(key); // trimming could potentially make empty, so validate here         this.key = key;         this.val = val;@@ -64,12 +65,12 @@ public class Attribute implements Map.Entry<String, String>, Cloneable  {     }      /**-     Set the attribute key; case is preserved.+     Set the attribute key.      @param key the new key; must not be null      */     public void setKey(String key) {         Validate.notNull(key);-        key = key.trim();+        key = StringUtil.trimAsciiWhitespace(key);         Validate.notEmpty(key); // trimming could potentially make empty, so validate here         if (parent != null) {             int i = parent.indexOfKey(this.key);@@ -315,14 +316,14 @@ public class Attribute implements Map.Entry<String, String>, Cloneable  {     // collapse unknown foo=null, known checked=null, checked="", checked=checked; write out others     protected static boolean shouldCollapseAttribute(final String key, @Nullable final String val, final Document.OutputSettings out) {         return (out.syntax() == Syntax.html &&-                (val == null || (val.isEmpty() || val.equalsIgnoreCase(key)) && Attribute.isBooleanAttribute(key)));+                (val == null || (val.isEmpty() || Normalizer.equalsIgnoreAsciiCase(val, key)) && Attribute.isBooleanAttribute(key)));     }      /**      * Checks if this attribute name is defined as a boolean attribute in HTML5      */     public static boolean isBooleanAttribute(final String key) {-        return Arrays.binarySearch(booleanAttributes, Normalizer.lowerCase(key)) >= 0;+        return Arrays.binarySearch(booleanAttributes, Normalizer.asciiLowerCase(key)) >= 0;     }      @Overridesrc/main/java/org/jsoup/nodes/Attributes.javaindex acaf8ba7..8f16280e 100644@@ -23,7 +23,8 @@ import java.util.NoSuchElementException; import java.util.Objects; import java.util.Set; -import static org.jsoup.internal.Normalizer.lowerCase;+import static org.jsoup.internal.Normalizer.asciiLowerCase;+import static org.jsoup.internal.Normalizer.equalsIgnoreAsciiCase; import static org.jsoup.nodes.Document.OutputSettings.Syntax.xml; import static org.jsoup.nodes.Range.AttributeRange.UntrackedAttr; @@ -35,9 +36,9 @@ import static org.jsoup.nodes.Range.AttributeRange.UntrackedAttr;  * {@link #add(String, String)} vs {@link #put(String, String)} is used.  * </p>  * <p>- * Attribute name and value comparisons are generally <b>case sensitive</b>. By default for HTML, attribute names are+ * Attribute name and value comparisons are generally <b>case-sensitive</b>. By default for HTML, attribute names are  * normalized to lower-case on parsing. That means you should use lower-case strings when referring to attributes by- * name.+ * name. Case-insensitive name comparisons fold only ASCII letters; non-ASCII characters are compared as written.  * </p>  *  * @author Jonathan Hedley, jonathan@hedley.net@@ -116,7 +117,7 @@ public class Attributes implements Iterable<Attribute>, Cloneable {     private int indexOfKeyIgnoreCase(String key) {         Validate.notNull(key);         for (int i = 0; i < size; i++) {-            if (key.equalsIgnoreCase(keys[i]))+            if (equalsIgnoreAsciiCase(key, keys[i]))                 return i;         }         return NotFound;@@ -598,12 +599,12 @@ public class Attributes implements Iterable<Attribute>, Cloneable {      /** Normalizes a key for the output syntax's case sensitivity. */     private static String comparisonKey(String key, Syntax syntax) {-        return syntax == xml ? key : lowerCase(key);+        return syntax == xml ? key : asciiLowerCase(key);     }      /** Compares keys with the requested case sensitivity. */     private static boolean keysEqual(String first, String second, boolean caseSensitive) {-        return caseSensitive ? first.equals(second) : first.equalsIgnoreCase(second);+        return caseSensitive ? first.equals(second) : equalsIgnoreAsciiCase(first, second);     }      @Override@@ -683,7 +684,7 @@ public class Attributes implements Iterable<Attribute>, Cloneable {             String key = keys[i];             assert key != null;             if (!isInternalKey(key))-                keys[i] = lowerCase(key);+                keys[i] = asciiLowerCase(key);         }     } src/main/java/org/jsoup/nodes/Element.javaindex b91e8e60..6abc8fe1 100644@@ -33,7 +33,7 @@ import java.util.regex.PatternSyntaxException; import java.util.stream.Collectors; import java.util.stream.Stream; -import static org.jsoup.internal.Normalizer.normalize;+import static org.jsoup.internal.Normalizer.asciiLowerCase; import static org.jsoup.nodes.Document.OutputSettings.Syntax.xml; import static org.jsoup.nodes.TextNode.lastCharIsWhitespace; import static org.jsoup.parser.Parser.NamespaceHtml;@@ -42,6 +42,7 @@ import static org.jsoup.select.Selector.evaluatorOf;  /**  An HTML Element consists of a tag name, attributes, and child nodes (including text nodes and other elements).+ Case-insensitive name lookups and name trimming use ASCII rules.  <p>  From an Element, you can extract data, traverse the node graph, and manipulate the HTML. */@@ -168,9 +169,8 @@ public class Element extends Node implements Iterable<Element> {     }      /**-     * Get the normalized name of this Element's tag. This will always be the lower-cased version of the tag, regardless-     * of the tag case preserving setting of the parser. For e.g., {@code <DIV>} and {@code <div>} both have a-     * normal name of {@code div}.+     * Get the normalized name of this Element's tag. For e.g., {@code <DIV>} and {@code <div>} both have a+     * normal name of {@code div}. See {@link Tag#normalName()}.      * @return normal name      */     @Override@@ -1272,12 +1272,12 @@ public class Element extends Node implements Iterable<Element> {      /**      * Finds elements, including and recursively under this element, with the specified tag name.-     * @param tagName The tag name to search for (case insensitively).+     * @param tagName The tag name to search for (case-insensitive; surrounding whitespace is trimmed).      * @return a matching unmodifiable list of elements. Will be empty if this element and none of its children match.      */     public Elements getElementsByTag(String tagName) {         Validate.notEmpty(tagName);-        tagName = normalize(tagName);+        tagName = asciiLowerCase(StringUtil.trimAsciiWhitespace(tagName));          return Collector.collect(new Evaluator.Tag(tagName), this);     }src/main/java/org/jsoup/parser/CharacterReader.javaindex 28378a35..f82afd2a 100644@@ -12,6 +12,8 @@ import java.io.Reader; import java.io.StringReader; import java.util.Arrays; +import static org.jsoup.internal.Normalizer.asciiLowerCase;+ /**  CharacterReader consumes tokens off a string. Used internally by jsoup. API subject to changes.  <p>If the underlying reader throws an IOException during any operation, the CharacterReader will throw an@@ -583,7 +585,7 @@ public final class CharacterReader implements AutoCloseable {     }      /**-     Checks if the current buffer position matches the sequence case-insensitively.+     Checks if the current buffer position matches the sequence using ASCII case-insensitive matching.      */     boolean matchesIgnoreCase(String seq) {         bufferUp();@@ -600,8 +602,8 @@ public final class CharacterReader implements AutoCloseable {             char target = charBuf[start + offset];             if (scan == target) continue; -            scan = Character.toUpperCase(scan);-            target = Character.toUpperCase(target);+            scan = asciiLowerCase(scan);+            target = asciiLowerCase(target);             if (scan != target) return false;         }         return true;src/main/java/org/jsoup/parser/HtmlTreeBuilder.javaindex b3e20488..23125691 100644@@ -301,7 +301,7 @@ public class HtmlTreeBuilder extends TreeBuilder {          */         if (Parser.NamespaceMathml.equals(el.tag().namespace())             && el.nameIs("annotation-xml")) {-            String encoding = Normalizer.normalize(el.attr("encoding"));+            String encoding = Normalizer.asciiLowerCase(el.attr("encoding"));             if (encoding.equals("text/html") || encoding.equals("application/xhtml+xml"))                 return true;         }src/main/java/org/jsoup/parser/HtmlTreeBuilderState.javaindex c3cfe33c..09b27bfd 100644@@ -14,6 +14,8 @@ import org.jspecify.annotations.Nullable;  import java.util.ArrayList; +import static org.jsoup.internal.Normalizer.asciiLowerCase;+import static org.jsoup.internal.Normalizer.equalsIgnoreAsciiCase; import static org.jsoup.internal.StringUtil.inSorted; import static org.jsoup.parser.HtmlTreeBuilder.isSpecial; import static org.jsoup.parser.HtmlTreeBuilderState.Constants.*;@@ -31,13 +33,13 @@ enum HtmlTreeBuilderState {             } else if (t.isDoctype()) {                 // todo: parse error check on expected doctypes                 Token.Doctype d = t.asDoctype();-                DocumentType doctype = new DocumentType(-                    tb.settings.normalizeTag(d.getName()), d.getPublicIdentifier(), d.getSystemIdentifier());+                String name = tb.settings.preserveTagCase() ? d.getName() : asciiLowerCase(d.getName());+                DocumentType doctype = new DocumentType(name, d.getPublicIdentifier(), d.getSystemIdentifier());                 doctype.setPubSysKey(d.getPubSysKey());                 tb.getDocument().appendChild(doctype);                 tb.onNodeInserted(doctype);                 // todo: quirk state check on more doctype ids, if deemed useful (most are ancient legacy and presumably irrelevant)-                if (d.isForceQuirks() || !doctype.name().equals("html") || doctype.publicId().equalsIgnoreCase("HTML"))+                if (d.isForceQuirks() || !doctype.name().equals("html") || equalsIgnoreAsciiCase(doctype.publicId(), "HTML"))                     tb.getDocument().quirksMode(Document.QuirksMode.quirks);                 tb.transition(BeforeHtml);             } else {@@ -422,7 +424,7 @@ enum HtmlTreeBuilderState {                 case "input":                     tb.reconstructFormattingElements();                     el = tb.insertEmptyElementFor(startTag);-                    if (!el.attr("type").equalsIgnoreCase("hidden"))+                    if (!equalsIgnoreAsciiCase(el.attr("type"), "hidden"))                         tb.framesetOk(false);                     break;                 case "hr":@@ -1024,7 +1026,7 @@ enum HtmlTreeBuilderState {                 } else if (name.equals("noscript")) {                     tb.startNoscript(startTag);                 } else if (name.equals("input")) {-                    if (!(startTag.hasAttributes() && startTag.attributes.get("type").equalsIgnoreCase("hidden"))) {+                    if (!(startTag.hasAttributes() && equalsIgnoreAsciiCase(startTag.attributes.get("type"), "hidden"))) {                         return anythingElse(t, tb);                     } else {                         tb.insertEmptyElementFor(startTag);src/main/java/org/jsoup/parser/ParseSettings.javaindex b31e5f8c..3d7a05b5 100644@@ -1,17 +1,18 @@ package org.jsoup.parser; +import org.jsoup.internal.StringUtil; import org.jsoup.nodes.Attributes;-import org.jspecify.annotations.Nullable; -import static org.jsoup.internal.Normalizer.lowerCase;-import static org.jsoup.internal.Normalizer.normalize;+import static org.jsoup.internal.Normalizer.asciiLowerCase;  /**  * Controls parser case settings, to optionally preserve tag and/or attribute name case.+ * Case conversion uses ASCII rules.+ * Programmatic name normalization also trims surrounding ASCII whitespace.  */ public class ParseSettings {     /**-     * HTML default settings: both tag and attribute names are lower-cased during parsing.+     * HTML defaults: lower-case tag and attribute names.      */     public static final ParseSettings htmlDefault;     /**@@ -56,22 +57,22 @@ public class ParseSettings {     }      /**-     * Normalizes a tag name according to the case preservation setting.+     * Normalizes a tag name according to these settings.      */     public String normalizeTag(String name) {-        name = name.trim();+        name = StringUtil.trimAsciiWhitespace(name);         if (!preserveTagCase)-            name = lowerCase(name);+            name = asciiLowerCase(name);         return name;     }      /**-     * Normalizes an attribute according to the case preservation setting.+     * Normalizes an attribute name according to these settings.      */     public String normalizeAttribute(String name) {-        name = name.trim();+        name = StringUtil.trimAsciiWhitespace(name);         if (!preserveAttributeCase)-            name = lowerCase(name);+            name = asciiLowerCase(name);         return name;     } @@ -80,9 +81,4 @@ public class ParseSettings {             attributes.normalize();         }     }--    /** Returns the normal name that a Tag will have (trimmed and lower-cased) */-    static String normalName(String name) {-        return normalize(name);-    } }src/main/java/org/jsoup/parser/Tag.javaindex aac1da4e..76a7ee7c 100644@@ -6,11 +6,13 @@ import org.jspecify.annotations.Nullable;  import java.util.Objects; +import static org.jsoup.internal.Normalizer.asciiLowerCase; import static org.jsoup.parser.Parser.NamespaceHtml;  /**  A Tag represents an Element's name and configured options, common throughout the Document. Options may affect the parse  and output.+ <p>A tag's normalized name uses ASCII lowercase; other characters are unchanged.</p>   @see TagSet  @see Parser#tagSet(TagSet) */@@ -54,7 +56,7 @@ public class Tag implements Cloneable {      @since 1.20.1      */     public Tag(String tagName, String namespace) {-        this(tagName, ParseSettings.normalName(tagName), namespace);+        this(tagName, asciiLowerCase(tagName), namespace);     }      /**@@ -65,7 +67,7 @@ public class Tag implements Cloneable {      @since 1.20.1      */     public Tag(String tagName) {-        this(tagName, ParseSettings.normalName(tagName), NamespaceHtml);+        this(tagName, asciiLowerCase(tagName), NamespaceHtml);     }      /** Path for TagSet defaults, no options set; normal name is already LC. */@@ -103,7 +105,7 @@ public class Tag implements Cloneable {     public Tag name(String tagName) {         if (is(RcData) || is(Data)) validateTextTagName(tagName);         this.tagName = tagName;-        this.normalName = ParseSettings.normalName(tagName);+        this.normalName = asciiLowerCase(tagName);         setParserOptions();         return this;     }@@ -133,7 +135,7 @@ public class Tag implements Cloneable {     }      /**-     * Get this tag's normalized (lowercased) name.+     * Get this tag's normalized name.      * @return the tag's normal name.      */     public String normalName() {src/main/java/org/jsoup/parser/TagSet.javaindex a55ef55d..51d840d5 100644@@ -1,6 +1,7 @@ package org.jsoup.parser;  import org.jsoup.helper.Validate;+import org.jsoup.internal.StringUtil; import org.jsoup.internal.SharedConstants; import org.jspecify.annotations.Nullable; @@ -10,6 +11,7 @@ import java.util.Map; import java.util.Objects; import java.util.function.Consumer; +import static org.jsoup.internal.Normalizer.asciiLowerCase; import static org.jsoup.parser.Parser.NamespaceHtml; import static org.jsoup.parser.Parser.NamespaceMathml; import static org.jsoup.parser.Parser.NamespaceSvg;@@ -137,13 +139,13 @@ public class TagSet {     Tag valueOf(String tagName, @Nullable String normalName, String namespace, boolean preserveTagCase) {         Validate.notNull(tagName);         Validate.notNull(namespace);-        if (normalName == null) tagName = tagName.trim(); // public API input; tokenizer names are already delimited+        if (normalName == null) tagName = StringUtil.trimAsciiWhitespace(tagName); // public API input; tokenizer names are already delimited         Validate.notEmpty(tagName);         Tag tag = get(tagName, namespace);         if (tag != null) return tag;          // not found by tagName, try by normal-        if (normalName == null) normalName = ParseSettings.normalName(tagName);+        if (normalName == null) normalName = asciiLowerCase(tagName);         tagName = preserveTagCase ? tagName : normalName;         tag = get(normalName, namespace);         if (tag != null) {src/main/java/org/jsoup/parser/Token.javaindex 44e58638..4d197d81 100644@@ -9,7 +9,7 @@ import org.jspecify.annotations.Nullable; import java.util.Arrays; import java.util.Objects; -import static org.jsoup.internal.Normalizer.lowerCase;+import static org.jsoup.internal.Normalizer.asciiLowerCase;  /**  * Parse tokens for the Tokeniser.@@ -171,9 +171,7 @@ abstract class Token {                 attributes = new Attributes();              if (attrName.hasData() && attributes.size() < MaxAttributes) {-                // the tokeniser has skipped whitespace control chars, but trimming could collapse to empty for other control codes, so verify here                 String name = attrName.value();-                name = name.trim();                 if (!name.isEmpty()) {                     String value;                     if (attrValue.hasData())@@ -243,7 +241,7 @@ abstract class Token {             attrRangeCount = 0;             for (int i = 0; i < count; i++) {                 String stagedName = Objects.requireNonNull(attrRangeNames[i]);-                String rangeName = settings.normalizeAttribute(stagedName);+                String rangeName = settings.preserveAttributeCase() ? stagedName : asciiLowerCase(stagedName);                 Range.AttributeRange existing = attributes.sourceRange(rangeName);                 if (!existing.isTracked()) {                     int rangeIndex = attrRangeIndex(i);@@ -301,7 +299,7 @@ abstract class Token {          final Tag name(String name) {             tagName.set(name);-            normalName = lowerCase(tagName.value());+            normalName = asciiLowerCase(tagName.value());             return this;         } @@ -314,7 +312,7 @@ abstract class Token {             // might have null chars - need to replace with null replacement character             append = append.replace(TokeniserState.nullChar, Tokeniser.replacementChar);             tagName.append(append);-            normalName = lowerCase(tagName.value());+            normalName = asciiLowerCase(tagName.value());         }          final void appendTagName(char append) {@@ -389,7 +387,7 @@ abstract class Token {         StartTag nameAttr(String name, Attributes attributes) {             this.tagName.set(name);             this.attributes = attributes;-            normalName = lowerCase(name);+            normalName = asciiLowerCase(name);             return this;         } src/main/java/org/jsoup/parser/Tokeniser.javaindex 91605a89..4765429f 100644@@ -8,6 +8,8 @@ import org.jspecify.annotations.Nullable;  import java.util.Arrays; +import static org.jsoup.internal.Normalizer.asciiLowerCase;+ /**  * Readers the input stream into tokens.  */@@ -88,7 +90,7 @@ final class Tokeniser {          if (token.type == Token.TokenType.StartTag) {             Token.StartTag startTag = (Token.StartTag) token;-            lastStartTag = startTag.name();+            lastStartTag = startTag.normalName();         } else if (token.type == Token.TokenType.EndTag) {             Token.EndTag endTag = (Token.EndTag) token;             if (endTag.hasAttributes())@@ -268,7 +270,7 @@ final class Tokeniser {      /** Test if the pending end tag matches the last emitted start tag. */     boolean isAppropriateEndTagToken() {-        return lastStartTag != null && tagPending.name().equalsIgnoreCase(lastStartTag);+        return lastStartTag != null && tagPending.normalName().equals(lastStartTag);     }      /** Test if appending the character would keep the pending end tag a prefix of the expected name. */@@ -278,8 +280,8 @@ final class Tokeniser {         String candidate = tagPending.normalName();         int length = candidate.length();         return length < lastStartTag.length()-            && lastStartTag.regionMatches(true, 0, candidate, 0, length)-            && lastStartTag.charAt(length) == next;+            && lastStartTag.startsWith(candidate)+            && lastStartTag.charAt(length) == asciiLowerCase(next);     }      void error(TokeniserState state) {src/main/java/org/jsoup/parser/XmlTreeBuilder.javaindex 7b92c9e5..1f834b23 100644@@ -25,6 +25,7 @@ import java.util.HashMap; import java.util.List; import java.util.Map; +import static org.jsoup.internal.Normalizer.asciiLowerCase; import static org.jsoup.parser.Parser.NamespaceXml;  /**@@ -223,7 +224,7 @@ public class XmlTreeBuilder extends TreeBuilder {     }      void insertDoctypeFor(Token.Doctype token) {-        DocumentType doctypeNode = new DocumentType(settings.normalizeTag(token.getName()), token.getPublicIdentifier(), token.getSystemIdentifier());+        DocumentType doctypeNode = new DocumentType(settings.preserveTagCase() ? token.getName() : asciiLowerCase(token.getName()), token.getPublicIdentifier(), token.getSystemIdentifier());         doctypeNode.setPubSysKey(token.getPubSysKey());         if (token.hasInternalSubset())             doctypeNode.setInternalSubset(token.getInternalSubset());@@ -243,7 +244,7 @@ public class XmlTreeBuilder extends TreeBuilder {      * @param endTag tag to close      */     protected void popStackToClose(Token.EndTag endTag) {-        String elName = settings.normalizeTag(endTag.name());+        String elName = settings.preserveTagCase() ? endTag.name() : asciiLowerCase(endTag.name());         Element firstFound = null;          for (int pos = stack.size() -1; pos >= 0; pos--) {src/main/java/org/jsoup/safety/Safelist.javaindex 13fb5abc..b9387a85 100644@@ -256,7 +256,7 @@ public class Safelist {          for (String tagName : tags) {             Validate.notEmpty(tagName);-            Validate.isFalse(tagName.equalsIgnoreCase("noscript"),+            Validate.isFalse(Normalizer.equalsIgnoreAsciiCase(tagName, "noscript"),                 "noscript is unsupported in Safelists, due to incompatibilities between parsers with and without script-mode enabled");             tagNames.add(TagName.valueOf(tagName));         }@@ -632,7 +632,7 @@ public class Safelist {         }          static TagName valueOf(String value) {-            return new TagName(Normalizer.lowerCase(value));+            return new TagName(Normalizer.asciiLowerCase(value));         }     } @@ -642,7 +642,7 @@ public class Safelist {         }          static AttributeKey valueOf(String value) {-            return new AttributeKey(Normalizer.lowerCase(value));+            return new AttributeKey(Normalizer.asciiLowerCase(value));         }     } src/main/java/org/jsoup/select/Evaluator.javaindex f3b6a353..23358173 100644@@ -17,7 +17,8 @@ import java.util.function.Predicate; import java.util.regex.Pattern;  import static org.jsoup.internal.Normalizer.lowerCase;-import static org.jsoup.internal.Normalizer.normalize;+import static org.jsoup.internal.Normalizer.asciiLowerCase;+import static org.jsoup.internal.StringUtil.trimAsciiWhitespace; import static org.jsoup.internal.StringUtil.normaliseWhitespace;  @@ -237,14 +238,14 @@ public abstract class Evaluator {          public AttributeStarting(String keyPrefix) {             Validate.notNull(keyPrefix); // OK to be empty - will find elements with any attributes-            this.keyPrefix = lowerCase(keyPrefix);+            this.keyPrefix = asciiLowerCase(keyPrefix);         }          @Override         public boolean matches(Element root, Element element) {             List<org.jsoup.nodes.Attribute> values = element.attributes().asList();             for (org.jsoup.nodes.Attribute attribute : values) {-                if (lowerCase(attribute.getKey()).startsWith(keyPrefix))+                if (asciiLowerCase(attribute.getKey()).startsWith(keyPrefix))                     return true;             }             return false;@@ -387,7 +388,7 @@ public abstract class Evaluator {         final Regex pattern;          public AttributeWithValueMatching(String key, Regex pattern) {-            this.key = normalize(key);+            this.key = asciiLowerCase(trimAsciiWhitespace(key));             this.pattern = pattern;         } @@ -422,7 +423,7 @@ public abstract class Evaluator {             Validate.notEmpty(key);             Validate.notNull(value); -            this.key = normalize(key);+            this.key = asciiLowerCase(trimAsciiWhitespace(key));             boolean quoted = value.startsWith("'") && value.endsWith("'")                 || value.startsWith("\"") && value.endsWith("\"");             if (quoted) {src/main/java/org/jsoup/select/QueryParser.javaindex 83b32232..3362bb98 100644@@ -16,8 +16,9 @@ import java.util.function.Function; import java.util.regex.Matcher; import java.util.regex.Pattern; +import static org.jsoup.internal.Normalizer.asciiLowerCase;+import static org.jsoup.internal.StringUtil.trimAsciiWhitespace; import static org.jsoup.select.StructuralEvaluator.ImmediateParentRun;-import static org.jsoup.internal.Normalizer.normalize;  /**  * Parses a CSS selector into an Evaluator tree.@@ -37,7 +38,7 @@ public class QueryParser implements AutoCloseable {      */     private QueryParser(String query) {         Validate.notEmpty(query);-        query = query.trim();+        query = trimAsciiWhitespace(query);         this.query = query;         this.tq = new TokenQueue(query);     }@@ -320,7 +321,7 @@ public class QueryParser implements AutoCloseable {         // todo - these aren't dealing perfectly with case sensitivity. For case sensitive parsers, we should also make         // the tag in the selector case-sensitive (and also attribute names). But for now, normalize (lower-case) for         // consistency - both the selector and the element tag-        String tagName = normalize(tq.consumeElementSelector());+        String tagName = asciiLowerCase(tq.consumeElementSelector());         Validate.notEmpty(tagName);          // namespaces:@@ -348,7 +349,7 @@ public class QueryParser implements AutoCloseable {      private Evaluator evaluatorForAttribute(TokenQueue cq) {         String key = cq.consumeToAny(AttributeEvals); // eq, not, start, end, contain, match, (no val)-        key = normalize(key);+        key = asciiLowerCase(trimAsciiWhitespace(key));         Validate.notEmpty(key);         Validate.isFalse(key.equals("abs:"), "Absolute attribute key must have a name");         cq.consumeWhitespace();@@ -386,7 +387,7 @@ public class QueryParser implements AutoCloseable {     private static final Pattern NthOffset = Pattern.compile("([+-])?(\\d+)");      private Evaluator cssNthChild(boolean last, boolean ofType) {-        String arg = normalize(consumeParens()); // arg is like "odd", or "-n+2", within nth-child(odd)+        String arg = asciiLowerCase(trimAsciiWhitespace(consumeParens())); // arg is like "odd", or "-n+2", within nth-child(odd)         final int step, offset;         if ("odd".equals(arg)) {             step = 2;src/main/java/org/jsoup/select/Selector.javaindex c28ea0e8..80ffc32d 100644@@ -14,10 +14,9 @@ import java.util.stream.Stream;  CSS element selector, that finds elements matching a query.   <h2>Selector syntax</h2>- <p>- A selector is a chain of simple selectors, separated by combinators. Selectors are <b>case-insensitive</b> (including- against elements, attributes, and attribute values).- </p>+ <p>A selector is a chain of simple selectors, separated by combinators.</p>+ <p>Tag and attribute names are matched ASCII case-insensitively, so non-ASCII case variants remain distinct.+ Attribute-value and case-insensitive text searches use Unicode case rules.</p>  <p>  The universal selector {@code *} is implicit when no element selector is supplied (i.e. {@code .header} and  {@code *.header} are equivalent).src/test/java/org/jsoup/internal/NormalizerTest.javanew file mode 100644index 00000000..fa927706@@ -0,0 +1,34 @@+package org.jsoup.internal;++import org.jsoup.MultiLocaleExtension.MultiLocaleTest;+import org.junit.jupiter.api.Test;++import java.util.Locale;++import static org.junit.jupiter.api.Assertions.*;++class NormalizerTest {+    @MultiLocaleTest void separatesAsciiAndUnicodeCase(Locale locale) {+        Locale.setDefault(locale);+        String input = "AZ ÄKİıſ😀\u0001 ";+        assertEquals("az ÄKİıſ😀\u0001 ", Normalizer.asciiLowerCase(input));+        assertEquals("az äki\u0307ıſ😀\u0001 ", Normalizer.lowerCase(input));+        assertEquals("", Normalizer.asciiLowerCase(null));+        assertEquals("", Normalizer.lowerCase(null));+        assertTrue(Normalizer.equalsIgnoreAsciiCase("TeXT/HTML", "text/html"));+        for (String[] pair : new String[][]{{"K", "k"}, {"İ", "i"}, {"ı", "i"}, {"ſ", "s"}, {"Ä", "ä"}})+            assertFalse(Normalizer.equalsIgnoreAsciiCase(pair[0], pair[1]));+        assertTrue(Normalizer.equalsIgnoreAsciiCase("Ä😀", "Ä😀"));+        assertFalse(Normalizer.equalsIgnoreAsciiCase("Ä", "ä"));+        assertFalse(Normalizer.equalsIgnoreAsciiCase("ſ", "s"));+        assertFalse(Normalizer.equalsIgnoreAsciiCase("x", null));+        assertFalse(Normalizer.equalsIgnoreAsciiCase("x", " x"));+    }++    @Test void trimsOnlyAsciiWhitespace() {+        String name = "\u0000\u0001\u000b\u00a0name\u0001";+        assertEquals(name, StringUtil.trimAsciiWhitespace(" \t\n\f\r" + name + "\r\f\n\t "));+        assertEquals("", StringUtil.trimAsciiWhitespace(" \t\n\f\r"));+        assertEquals("", StringUtil.trimAsciiWhitespace(""));+    }+}src/test/java/org/jsoup/nodes/AttributeTest.javaindex 4cff3205..399236da 100644@@ -116,4 +116,13 @@ public class AttributeTest {         Attribute attr = new Attribute("one", "two");         assertEquals("", attr.namespace());     }++    @Test void trimsWhitespaceButPreservesNameControls() {+        Attribute attr = new Attribute(" \tDATA-X\u0001\n", "one");+        assertEquals("DATA-X\u0001", attr.getKey());+        attr.setKey(" \r\u0001\f");+        assertEquals("\u0001", attr.getKey());+        assertEquals("_=\"one\"", attr.html()); // serialization still repairs invalid HTML names+    }+ }src/test/java/org/jsoup/nodes/AttributesTest.javaindex 6e694470..e9ea8835 100644@@ -473,4 +473,14 @@ public class AttributesTest {         assertTrue(attrs.isEmpty());     } ++    @Test void repairedHtmlKeysUseAsciiCollisionChecks() {+        Attributes attrs = new Attributes();+        attrs.add("K_", "unicode");+        attrs.add("k\u0001", "repaired");+        assertEquals(" K_=\"unicode\" k_=\"repaired\"", attrs.html());+        attrs.add("K_", "original");+        assertEquals(" K_=\"unicode\" _k_=\"repaired\" K_=\"original\"", attrs.html());+    }+ }src/test/java/org/jsoup/parser/CharacterReaderTest.javaindex 17c9dde0..3c7e549e 100644@@ -503,4 +503,18 @@ public class CharacterReaderTest {         assertEquals('&', r.consume());     } ++    @Test void keywordMatchingUsesAsciiCaseAcrossRefills() {+        for (int offset : new int[]{0, CharacterReader.BufferSize - 3, CharacterReader.BufferSize + 3}) {+            String padding = StringUtil.padding(offset, offset);+            try (CharacterReader reader = new CharacterReader(padding + "PUBLİC PUBLIC")) {+                for (int i = 0; i < offset; i++) reader.consume();+                assertFalse(reader.matchesIgnoreCase("public"));+                assertTrue(reader.matchConsumeIgnoreCase("publİc"));+                reader.consume();+                assertTrue(reader.matchConsumeIgnoreCase("public"));+            }+        }+    }+ }src/test/java/org/jsoup/parser/HtmlParserTest.javaindex 2addc411..dbc69fc1 100644@@ -1542,7 +1542,12 @@ public class HtmlParserTest {      @Test public void handlesControlCodeInAttributeName() {         Document doc = Jsoup.parse("<p><a \06=foo>One</a><a/\06=bar><a foo\06=bar>Two</a></p>");-        assertEquals("<p><a>One</a><a></a><a foo=\"bar\">Two</a></p>", doc.body().html());+        assertEquals("foo", doc.select("a").get(0).attr("\06"));+        assertEquals("bar", doc.select("a").get(1).attr("\06"));+        assertEquals("bar", doc.select("a").get(2).attr("foo\06"));+        assertFalse(doc.select("a").get(2).hasAttr("foo"));+        // invalid names are repaired for serialization, but are not trimmed or dropped while parsing+        assertEquals("<p><a _=\"foo\">One</a><a _=\"bar\"></a><a foo_=\"bar\">Two</a></p>", doc.body().html());     }      @Test public void caseSensitiveParseTree() {src/test/java/org/jsoup/parser/NameNormalizationTest.javanew file mode 100644index 00000000..1a53959f@@ -0,0 +1,121 @@+package org.jsoup.parser;++import org.jsoup.Jsoup;+import org.jsoup.internal.StringUtil;+import org.jsoup.nodes.Document;+import org.jsoup.nodes.Element;+import org.jsoup.nodes.Range;+import org.junit.jupiter.api.Test;++import java.util.Locale;++import static org.junit.jupiter.api.Assertions.*;++class NameNormalizationTest {+    @Test void integrationEncodingMatchesWithoutTrimmingOrUnicodeFolding() {+        for (String encoding : new String[]{"text/html", "application/xhtml+xml"}) {+            for (String value : new String[]{encoding, encoding.toUpperCase(Locale.ROOT)}) {+                Document doc = Jsoup.parse("<math><annotation-xml encoding='" + value + "'><xmp><b>One</b></xmp>");+                assertEquals(Parser.NamespaceHtml, doc.expectFirst("xmp").tag().namespace());+                assertEquals("<b>One</b>", doc.expectFirst("xmp").data());+            }+            for (String whitespace : new String[]{" ", "\t", "\n", "\r", "\f", "\u0001", "\u000b", "\u00a0"}) {+                for (String value : new String[]{whitespace + encoding, encoding + whitespace}) {+                    Document doc = Jsoup.parse("<math><annotation-xml encoding='" + value + "'><xmp><b>One</b></xmp>");+                    assertEquals(Parser.NamespaceMathml, doc.expectFirst("xmp").tag().namespace(), value);+                    assertNotNull(doc.selectFirst("body > b"));+                }+            }+        }+        Document doc = Jsoup.parse("<math><annotation-xml encoding='applıcation/xhtml+xml'><xmp>One</xmp>");+        assertEquals(Parser.NamespaceMathml, doc.expectFirst("xmp").tag().namespace());+    }++    @Test void integrationEncodingAttributeNamesStayDistinct() {+        for (String key : new String[]{"encodıng", "encoding\u0001"}) {+            Document doc = Jsoup.parse("<math><annotation-xml " + key + "='text/html'><xmp>One</xmp>");+            assertEquals(Parser.NamespaceMathml, doc.expectFirst("xmp").tag().namespace());+            assertFalse(doc.expectFirst("annotation-xml").hasAttr("encoding"));+        }+        Document doc = Jsoup.parse("<math><annotation-xml ENCODING='text/html'><xmp>One</xmp>");+        assertEquals(Parser.NamespaceHtml, doc.expectFirst("xmp").tag().namespace());+    }++    @Test void doctypeNameNormalizationRespectsCaseSettings() {+        for (ParseSettings settings : new ParseSettings[]{ParseSettings.htmlDefault, ParseSettings.preserveCase}) {+            Document doc = Jsoup.parse("<!DOCTYPE HTMK\u0001><p>One", Parser.htmlParser().settings(settings));+            assertEquals(settings.preserveTagCase() ? "HTMK\u0001" : "htmK\u0001", doc.documentType().name());+        }+    }++    @Test void namesRetainNonAsciiLettersAndControls() {+        Document doc = Jsoup.parse("<LINK>One</LINK><p\u0001>Two</p\u0001><p>Three</p>");+        Element link = doc.body().child(0);+        assertEquals("linK", link.tagName());+        assertFalse(link.tag().isEmpty());+        assertEquals("One", link.text());+        assertEquals("Two", doc.getElementsByTag("p\u0001").text());+        assertEquals("Three", doc.getElementsByTag(" \tP\n").text());+        assertEquals("Two", doc.select("p\\\u0001").text());+        assertEquals("One", doc.select("LINK").text());+        assertEquals(doc.body().html(), Jsoup.parse(doc.body().html()).body().html());+        assertEquals("p\u0001", new Tag("p\u0001").normalName());+        assertEquals("p\u0001", Tag.valueOf(" p\u0001 ").normalName());+    }++    @Test void attributesKeepIdentityAndSourceRanges() {+        String html = "<p DATA-X\u0001=one data-x=two K=three k=four Ä=five ä=six>";+        for (ParseSettings settings : new ParseSettings[]{ParseSettings.htmlDefault, ParseSettings.preserveCase}) {+            Document doc = Jsoup.parse(html, Parser.htmlParser().settings(settings).setTrackPosition(true));+            Element p = doc.expectFirst("p");+            assertEquals(6, p.attributes().size());+            assertEquals("one", p.attr("data-x\u0001"));+            assertEquals("two", p.attr("data-x"));+            assertEquals("three", p.attr("K"));+            assertEquals("four", p.attr("k"));+            assertEquals("five", p.attr("Ä"));+            assertEquals("six", p.attr("ä"));+            p.attributes().forEach(attr -> assertEquals(attr.getValue(), p.attr(attr.getKey())));+            String firstName = settings.preserveAttributeCase() ? "DATA-X\u0001" : "data-x\u0001";+            Range range = p.attributes().sourceRange(firstName).nameRange();+            assertEquals("DATA-X\u0001", html.substring(range.start().pos(), range.end().pos()));+            assertEquals(6, Jsoup.parse(p.outerHtml()).expectFirst("p").attributes().size());+            assertEquals("one", p.clone().attr("data-x\u0001"));+            p.attr("K", "updated");+            assertEquals("three", p.attr("K"));+            p.removeAttr("k");+            assertTrue(p.hasAttr("K"));+            assertFalse(p.hasAttr("k"));+        }+    }++    @Test void xmlClosesExactNamesAndNormalizesOnlyAsciiWhenRequested() {+        Document doc = Jsoup.parse("<r><a>one</a\u0001><b>two</b></r>", "", Parser.xmlParser());+        assertEquals("a", doc.expectFirst("b").parent().tagName());+        String xml = "<R><x-Ä X='1' x='2' K='3' k='4'>One</x-ä><B>Two</B></x-Ä></R>";+        for (ParseSettings settings : new ParseSettings[]{ParseSettings.preserveCase, ParseSettings.htmlDefault}) {+            doc = Jsoup.parse(xml, "", Parser.xmlParser().settings(settings));+            Element a = doc.child(0).child(0);+            assertEquals("x-Ä", a.tagName());+            assertEquals("x-Ä", a.child(0).parent().tagName());+            assertEquals(settings.preserveAttributeCase() ? 4 : 3, a.attributes().size());+            assertEquals("3", a.attr("K"));+            assertEquals("4", a.attr("k"));+        }+    }++    @Test void rawTextEndNamesUseAsciiAcrossBufferBoundaries() {+        for (int length : new int[]{0, CharacterReader.BufferSize - 8, CharacterReader.BufferSize + 3}) {+            String padding = StringUtil.padding(length, length);+            Document doc = Jsoup.parse("<script>" + padding + "</ſcript><b>literal</b></SCRIPT><p>After</p>");+            assertNull(doc.selectFirst("b"));+            assertEquals("After", doc.expectFirst("p").text());+            assertTrue(doc.expectFirst("script").data().endsWith("</ſcript><b>literal</b>"));+        }+        TagSet tags = TagSet.Html();+        tags.add(new Tag("custom-Ä").set(Tag.Data));+        Document doc = Jsoup.parse("<custom-Ä>One</custom-ä><b>literal</b></CUSTOM-Ä><p>After</p>", Parser.htmlParser().tagSet(tags));+        assertNull(doc.selectFirst("b"));+        assertEquals("After", doc.expectFirst("p").text());+    }+}src/test/java/org/jsoup/safety/SafelistTest.javaindex 90b4fd61..125913e0 100644@@ -96,5 +96,18 @@ public class SafelistTest {         assertNull(safelist);     } +    @Test+    void namesUseAsciiCaseFolding() {+        Safelist safelist = Safelist.none()+            .addTags("P", "X-Ä")+            .addAttributes("P", "DATA-Ä");++        assertTrue(safelist.isSafeTag("p"));+        assertTrue(safelist.isSafeTag("x-Ä"));+        assertFalse(safelist.isSafeTag("x-ä"));+        assertTrue(safelist.isSafeAttribute("p", null, new Attribute("data-Ä", TEST_VALUE)));+        assertFalse(safelist.isSafeAttribute("p", null, new Attribute("data-ä", TEST_VALUE)));+    }+  }src/test/java/org/jsoup/select/SelectorTest.javaindex 7ca5de20..c20bcf5d 100644@@ -1800,4 +1800,18 @@ public class SelectorTest {         assertTrue(threw);     } ++    @Test void nameMatchingUsesAsciiButTextMatchingUsesUnicode() {+        Document doc = Jsoup.parse("<x-Ä data-Ä='VALUE'>Äpfel</x-Ä><x-ä data-ä='value'>Other</x-ä>");+        assertEquals("Äpfel", doc.select("X-Ä").text());+        assertEquals("Other", doc.select("x-ä").text());+        assertEquals("Äpfel", doc.select("[DATA-Ä]").text());+        assertEquals("Äpfel", doc.select("[DATA-Ä=value]").text());+        assertEquals("Äpfel", doc.select("[^DATA-Ä]").text());+        assertEquals("Äpfel", doc.select("x-Ä:contains(äPFEL)").text());+        Element el = new Element(new org.jsoup.parser.Tag("x "), "");+        el.text("Space");+        assertEquals("Space", el.select("x\\ :not(p)").text());+    }+ }