Pre-push review: T-1704 diacritic-insensitive search highlights

diff --git a/prism/Resources/WebRenderer/prism-search.js b/prism/Resources/WebRenderer/prism-search.jsindex 797742a..1db39e8 100644--- a/prism/Resources/WebRenderer/prism-search.js+++ b/prism/Resources/WebRenderer/prism-search.js@@ -55,26 +55,87 @@      // ---- Text matching (mirrors SearchHighlightApplicator) ---------------- -    // Case-insensitive occurrence offsets of `query` within `haystack`. Offsets are-    // UTF-16 code-unit indices into `haystack`, so they map directly onto the-    // concatenated textContent walked below. (Native counting is case- and-    // diacritic-insensitive; case-insensitivity is the common path and preserves-    // offsets 1:1. Diacritic folding would shift offsets, so it is intentionally not-    // applied here — the native count still owns parity, and the host badge/text-    // remains navigable.)-    function findOffsets(haystack, query) {-        var offsets = [];-        if (!query) { return offsets; }-        var lowerHay = haystack.toLowerCase();-        var lowerQuery = query.toLowerCase();+    // Combining marks stripped by the diacritic fold (any Unicode Mark).+    var COMBINING_MARKS = /\p{M}/gu;++    // Folds text the way native comparison does (SearchService.searchCompareOptions =+    // [.caseInsensitive, .diacriticInsensitive]): canonical decomposition, combining+    // marks stripped, lowercased. Known limitations: characters without a canonical+    // decomposition (e.g. ø, đ) are not folded — shared with native counting, so+    // parity holds there — and a code point whose decomposition yields SEVERAL+    // non-combining units (e.g. a Hangul syllable decomposing to multiple Jamo under+    // NFD) pushes the same source offset into the map several times, so a match+    // boundary landing inside such an expansion could collapse a range. NOT shared+    // with native: ICU full case folding (ß↔ss, compatibility ligatures like fi),+    // which native's case-insensitive compare applies but toLowerCase() does not, so+    // those stay counted-but-unhighlighted. Native still owns counts for all these+    // edge cases.+    function foldCodePoint(cp, raw) {+        if (cp < 128) {+            // ASCII fast path: no decomposition possible.+            return raw.toLowerCase();+        }+        return raw.normalize("NFD").replace(COMBINING_MARKS, "").toLowerCase();+    }++    // Pure-ASCII text needs no decomposition and lowercases length-preservingly, so+    // the folded→source mapping is the identity (signalled with map: null).+    var ASCII_ONLY = /^[\x00-\x7F]*$/;++    // Folds `text` and records, for every UTF-16 unit of the folded output, the+    // source offset of the code point that produced it, so folded match offsets+    // map back onto the original text even though folding changes lengths. Returns+    // `map: null` (identity) for pure-ASCII text so the common unaccented case keeps+    // the single native toLowerCase() instead of the per-code-point loop.+    function foldWithMap(text) {+        if (ASCII_ONLY.test(text)) {+            return { folded: text.toLowerCase(), map: null };+        }+        var folded = "";+        var map = [];+        var i = 0;+        while (i < text.length) {+            var cp = text.codePointAt(i);+            var charLength = cp > 0xFFFF ? 2 : 1;+            var foldedChar = foldCodePoint(cp, text.substr(i, charLength));+            for (var j = 0; j < foldedChar.length; j++) { map.push(i); }+            folded += foldedChar;+            i += charLength;+        }+        return { folded: folded, map: map };+    }++    // Occurrence ranges ({ start, end } UTF-16 code-unit indices into `haystack`) of+    // `query` within `haystack` under the native comparison contract (case- AND+    // diacritic-insensitive, T-1704). Matching runs over folded text; each folded+    // match is mapped back to source coordinates, so ranges cover the accented+    // original (including trailing combining marks, which fold to nothing and are+    // absorbed by the next mapped offset). Match lengths therefore vary — `résumé`+    // is a 6-unit query but an up-to-8-unit range in decomposed source text.+    function findMatchRanges(haystack, query) {+        var ranges = [];+        if (!query) { return ranges; }+        var foldedQuery = foldWithMap(query).folded;+        if (!foldedQuery) { return ranges; }+        var hay = foldWithMap(haystack);         var from = 0;         while (true) {-            var index = lowerHay.indexOf(lowerQuery, from);+            var index = hay.folded.indexOf(foldedQuery, from);             if (index < 0) { break; }-            offsets.push(index);-            from = index + lowerQuery.length;+            var foldedEnd = index + foldedQuery.length;+            if (hay.map === null) {+                // Identity mapping (pure-ASCII haystack): folded offsets ARE+                // source offsets.+                ranges.push({ start: index, end: foldedEnd });+            } else {+                ranges.push({+                    start: hay.map[index],+                    end: foldedEnd < hay.folded.length ? hay.map[foldedEnd] : haystack.length,+                });+            }+            from = foldedEnd;         }-        return offsets;+        return ranges;     }      // Collects the block's text nodes (excluding Prism chrome: copy buttons, badges,@@ -212,13 +273,12 @@             if (!section || !sectionInWindow(section)) { continue; }              var map = textNodeMap(section);-            var offsets = findOffsets(map.text, state.query);-            var queryLength = state.query.length;+            var matches = findMatchRanges(map.text, state.query);             var currentOrdinal = (entry.current && entry.current.kind === "text")                 ? entry.current.ordinal : -1; -            for (var i = 0; i < offsets.length; i++) {-                var range = rangeFor(map, offsets[i], offsets[i] + queryLength);+            for (var i = 0; i < matches.length; i++) {+                var range = rangeFor(map, matches[i].start, matches[i].end);                 if (!range) { continue; }                 allHighlight.add(range);                 if (i === currentOrdinal) {@@ -311,4 +371,17 @@     bridge.searchHighlightCount = function () {         return allHighlight ? allHighlight.size : 0;     };++    // The rendered text of every range registered on the "all matches" highlight, in+    // registration order. Exposed for the search-parity suite so it can assert the+    // highlights cover the right characters, not just that the count matches — an+    // offset-mapping regression that shifts ranges while preserving the count would+    // pass a count-only check. Returns [] when the API is unavailable.+    bridge.searchHighlightTexts = function () {+        var texts = [];+        if (allHighlight) {+            allHighlight.forEach(function (range) { texts.push(range.toString()); });+        }+        return texts;+    }; })();

diff --git a/prismTests/WebRendering/WebSearchParityTests.swift b/prismTests/WebRendering/WebSearchParityTests.swiftindex 44414d3..002d820 100644--- a/prismTests/WebRendering/WebSearchParityTests.swift+++ b/prismTests/WebRendering/WebSearchParityTests.swift@@ -101,6 +101,77 @@ struct WebSearchParityTests {         #expect(total == 3)     } +    /// Native counting is case- AND diacritic-insensitive+    /// (`SearchService.searchCompareOptions`), so `resume` matches `résumé` and+    /// `café` matches `cafe`. prism-search.js must apply the same folding when it+    /// re-finds the query in the rendered text; lowercasing alone leaves counted+    /// matches without a highlight and breaks current-match scrolling (T-1704).+    @Test("Diacritic-insensitive queries highlight accented matches (T-1704)")+    func diacriticInsensitiveCountParity() async throws {+        let markdown = "Send your résumé to the café.\n\nA plain resume and a cafe reference.\n"+        let parsed = MarkdownBlockParser.parseWithFootnotes(markdown)+        let context = SearchContext(showHTMLComments: false, footnoteData: parsed.footnoteData)++        let harness = try await WebDocumentLiveHarness.make(+            blocks: parsed.blocks,+            footnotes: parsed.footnoteData,+            featureScripts: ["prism-search"]+        )+        _ = try await harness.waitForMessage(type: "ready")++        // Accented and unaccented spellings in both directions: each query must+        // match both the accented and the plain occurrence (native count 2), and+        // the registered ranges must cover exactly those spellings — a count-only+        // check would stay green if the folded→source offset mapping shifted every+        // range by a fixed amount within node bounds.+        let cases: [(query: String, expectedTexts: [String])] = [+            ("resume", ["resume", "résumé"]),+            ("cafe", ["cafe", "café"]),+            ("café", ["cafe", "café"]),+        ]+        for (query, expectedTexts) in cases {+            let counts = parsed.blocks.map {+                SearchService.countMatches(query: query, in: $0, context: context)+            }+            let states = SearchStateFeeder.buildStates(+                query: query,+                blocks: parsed.blocks,+                matchCountsPerBlock: counts,+                currentGlobalMatchIndex: nil,+                context: context+            )+            let nativeTextMatches = states.reduce(0) { $0 + $1.textMatchCount }+            #expect(nativeTextMatches == 2, "query '\(query)': native should count both spellings")++            let json = SearchStateFeeder.encode(query: query, states: states)+            try await harness.send(.setSearchState(json: json))++            let count = try await harness.page.callJavaScript(+                "return window.__prismBridge && window.__prismBridge.searchHighlightCount "+                    + "? window.__prismBridge.searchHighlightCount() : -1;",+                contentWorld: harness.bridgeWorld+            )+            let rendered = (count as? Int) ?? Int((count as? Double) ?? -1)+            #expect(+                rendered == nativeTextMatches,+                "query '\(query)': rendered \(rendered) != native \(nativeTextMatches)"+            )++            // Content parity: the highlighted ranges must land on the actual+            // spellings, not merely produce the right number of ranges.+            let texts = try await harness.page.callJavaScript(+                "return window.__prismBridge && window.__prismBridge.searchHighlightTexts "+                    + "? window.__prismBridge.searchHighlightTexts() : [];",+                contentWorld: harness.bridgeWorld+            )+            let highlightTexts = (texts as? [String]) ?? []+            #expect(+                highlightTexts.sorted() == expectedTexts,+                "query '\(query)': highlighted text \(highlightTexts) should cover both spellings"+            )+        }+    }+     /// A comment block nested inside a blockquote is emitted both ways and     /// hidden by the stylesheet when the toggle is off (T-1638). Its text     /// must not become a highlight target while hidden: native counts only