Implementation Details

def convert_american_to_british_spelling(  # noqa: C901
    text: str, strict: bool = False
) -> Any:
    """
    Convert American English spelling to British English spelling.

    Args:
        text: The text to convert.
        strict: Whether to raise an exception if a word cannot be converted.

    Returns:
        The text with American English spelling converted to British English spelling.
    """
    if not text.strip():
        return text
    try:

        def should_skip_word(word: str, pre: str, post: str, match_start: int, match_end: int) -> bool:
            """Check if the word should be skipped for conversion."""
            # Skip if within code blocks
            if "`" in pre or "`" in post:
                return True

            # Skip if word is in the ignore_list
            if word.lower() in CONVERSION_IGNORE_LIST:
                return True

            # Check for hyphenated terms (e.g., "3-color", "x-coordinate")
            # If the word is part of a hyphenated term, we should skip it
            if "-" in pre and pre.rstrip().endswith("-"):
                return True

            # Check for URL/URI context
            line_start = text.rfind("\n", 0, match_start)
            if line_start == -1:
                line_start = 0
            else:
                line_start += 1

            line_end = text.find("\n", match_end)
            if line_end == -1:
                line_end = len(text)

            line_context = text[line_start:line_end]

            # Skip if word appears to be in a URL/URI
            return "://" in line_context or "www." in line_context

        def preserve_capitalization(original: str, replacement: str) -> str:
            """Preserve the capitalization from the original word in the replacement."""
            if original.isupper():
                return replacement.upper()
            elif original.istitle():
                return replacement.title()
            return replacement

        def replace_word(match: re.Match) -> Any:
            """
            Replace a word with its British English spelling.

            Args:
                match: The match object.

            Returns:
                The word with its spelling converted to British English.
            """
            # The first group contains any leading punctuation/spaces
            # The second group contains the word
            # The third group contains any trailing punctuation/spaces
            pre, word, post = match.groups()

            if should_skip_word(word, pre, post, match.start(), match.end()):
                return match.group(0)

            if american_spelling_exists(word.lower()):
                try:
                    british = get_british_spelling(word.lower())
                    british = preserve_capitalization(word, british)
                    return pre + british + post
                except Exception:
                    if strict:
                        raise
            return match.group(0)

        # Match any word surrounded by non-letter characters
        # Group 1: Leading non-letters (including empty)
        # Group 2: The word itself (only letters)
        # Group 3: Trailing non-letters (including empty)
        pattern = r"([^a-zA-Z]*?)([a-zA-Z]+)([^a-zA-Z]*?)"
        return re.sub(pattern, replace_word, text)
    except Exception:
        if strict:
            raise
        return text