How capture this pattern with Swift's new Regex?

I want to use Swift 5.7's new Regex for my IRC client.
Take a IRC message like this:

:zirconium.libera.chat NOTICE * :*** Checking Ident\r\n:zirconium.libera.chat NOTICE * :*** Looking up your hostname...\r\n:zirconium.libera.chat NOTICE * :*** Couldn't look up your hostname\r\n

The pattern is a colon : immediately followed by a name (words and also other characters like dot . ) and then, for now, all else I want to extract is the string followed by the last colon : .

I tried this:

let pattern =  Regex {
        ":"
        Capture {
            NegativeLookahead {
                .whitespace
            }
            OneOrMore { .any }
        }
        OneOrMore { .any }
        ":"
        Capture {
            OneOrMore { .any }
        }
        "\r\n"
    }

My problem is that it's matching as much as possible and not just until the first \r\n.
I used NegatieLookahead in my code, but I'm not sure how to use it to only match until the first and smallest match, and not as much as possible.

So I want for the first part of the match to return :zirconium.libera.chat and for the second *** Checking Ident\.
What it does currently is it returns for the server part it identifies all the content including whitespaces as much as possible, up until the last whitespace.

I've used String's firstMatch method. Maybe there's another method like prefixMatch? It didn't seem to make a difference. Here's. the whole code:

Never mind, the problem was that I was supposed to capture the Negativelookahead as well. So:

        Capture {
            OneOrMore {
                NegativeLookahead {
                    .whitespace
                }
                CharacterClass.any
            }
        }

instead of:

        Capture {
            NegativeLookahead {
                .whitespace
            }
            OneOrMore { .any }
        }

I also needed to do another Negativelookahead. So just in case anyone is interested on how do a minimal parsing of a IRC message, this would be it:

class MessageParser {
    
    private var buff = ""
    
    private let pattern = Regex {
        ":"
        Capture {
            OneOrMore {
                NegativeLookahead {
                    .whitespace
                }
                CharacterClass.any
            }
        }
        OneOrMore {
            NegativeLookahead {
                ":"
            }
            CharacterClass.any
        }
        Capture {
            OneOrMore {
                NegativeLookahead {
                    "\r\n"
                }
                CharacterClass.any
            }
        }
        "\r\n"
    }
    public func parse(_ message: String) -> String? {
        let message = buff + message
        
        if let match = message.prefixMatch(of: pattern) {
            let (wholeMatch, sender, content ) = match.output
            buff = String(message.dropFirst(wholeMatch.count))
            return String("\(sender): \(content)")
        } else {
            return nil
        }

    }
}

To my understanding, the regex builder just builds what is possible with regular expressions written in the „traditional“ syntax? So this is more a question about how to get the regex right, so to speak? I always like to use a good online regex tester like https://regex101.com/ (using the „traditional“ syntax). The shorter syntax should make trying things out faster (but this might be a personal taste). Tip: Lookarounds are really needed in some cases, but sometimes there is an easier solution, e.g. when you know about the characters in a part that you would like to find.

This is not quite right; there are some advanced features of the builder that cannot be easily expressed in traditional regex syntax (e.g. Foundation regex components), but in this case your advice is sound.