function HtmlBoxWidget:_findMatchesOnPage(page_idx, search_text)
  local page = self.document:openPage(page_idx)
  if not page then return nil end

  local lines = page:getPageText()
  page:close()

  if not lines or type(lines) ~= "table" then return nil end

  -- Build searchable content with position mapping
  local content_parts = {}
  local word_map = {}
  local current_pos = 0

  for _, line in ipairs(lines) do
      if type(line) == "table" then
          for _, word_obj in ipairs(line) do
              if word_obj and word_obj.word then
                  -- Note: We lowercase words BEFORE building the position map because
                  --       case conversion can change UTF-8 byte lengths (e.g., Turkish İ→i: 2 bytes→1 byte).
                  --       If we lowercased after, our byte positions would be misaligned with the search string.
                  -- e.g.,
                  -- print("Original:", test, "Bytes:", #test)    -->    Original:     İİİİİ hello world       Bytes:     22
                  -- print("Lowered:", lower, "Bytes:", #lower)   -->    Lowered:      iiiii hello world       Bytes:     17
                  local word_text = Utf8Proc.lowercase(word_obj.word, false)
                  local start_pos = current_pos + 1

                  table.insert(content_parts, word_text)
                  table.insert(content_parts, " ")
                  current_pos = current_pos + #word_text + 1 -- +1 for space

                  table.insert(word_map, {
                      start_pos = start_pos,
                      end_pos = start_pos + #word_text - 1,
                      box = word_obj,
                      line = line
                  })
              end
          end
      end
  end
  local content = table.concat(content_parts)

  -- Search in the already-lowercased content
  local search_lower = Utf8Proc.lowercase(search_text, false)
  local match_rects = {}
  local search_start = 1
  local word_index = 1     -- Track position in word_map
  local last_word_idx = -1 -- Track last added word to prevent redundant rects

  -- Algorithm is O(n+m), n: number of words, m: matches. It makes a single forward pass
  -- through the word array, collecting rectangles for m matches along the way.
  while true do
      local match_start, match_end = content:find(search_lower, search_start, true)
      if not match_start then break end

      -- Skip words that end before this match starts, word_index only advances forward.
      while word_map[word_index] and word_map[word_index].end_pos < match_start do
          word_index = word_index + 1
      end

      -- Collect all words that overlap with this match
      local i = word_index
      while word_map[i] and word_map[i].start_pos <= match_end do
          local word_mapping = word_map[i]
          local overlap_start = math.max(word_mapping.start_pos, match_start)
          local overlap_end = math.min(word_mapping.end_pos, match_end)

          -- Ensure we only add the rect if there is an overlap and we haven't added this word yet
          if overlap_start <= overlap_end and i > last_word_idx then
              local rect = Geom:new{
                  x = word_mapping.box.x0,
                  y = word_mapping.line.y0,
                  w = word_mapping.box.x1 - word_mapping.box.x0,
                  h = word_mapping.line.y1 - word_mapping.line.y0,
              }
              table.insert(match_rects, rect)
              last_word_idx = i
          end
          i = i + 1
      end -- while word overlap
      -- Note: Moving to match_end + 1 avoids re-processing the same match, but
      --       it will skip overlapping results (e.g., searching "aba" in "ababa"
      --       will only return the first instance).
      search_start = match_end + 1
  end -- while true
  return #match_rects > 0 and match_rects or nil
end