Try:
^(((?!/lists/|\.aspx).)*)\.aspx
(with the 'ignore case' option in) assuming that the text you want to match starts at the beginning of the string.
What this does is step through each character looking for either the "/lists/" or ".aspx" sequences. If the following text is neither, it captures the character and moves on. If either is found, then it stops and checks for the ".aspx" sequence which indicates the end of a successful match. If the stepping/checking process stopped on the "/lists/" text, then the final match will fail and that fails the whole pattern.
The reason your pattern doesn't work is because I think you have the wrong idea about how regex engines work and/or how lookarounds behave. What the '(.+)' part of your pattern does is to start at the beginning of the string and match every character to the end of the string (or line if the "singleline' option is clear). It THEN moves to the next part of the pattern - '(?!/Lists/)' which checks to see of the following characters are NOT the "/Lists/" sequence; in this case we are either at the end of the string or at a newline character - in either case the next is not "/Lists/" (indicates a fail) and so the lookahead succeeds (because it is a negative lookahead).
It then moves on to the next part of the pattern which is the "\.aspx" sequence. Again we are either at the end of the string or at a newline (remember that the lookahead does not alter the current text position pointer) and so reports a "fail". This makes the regex engine start to backtrack a character at a time, releasing the characters that the '(.+)' part previously matched. As each character is released, the regex engine will recheck the lookahead which will generally fail (given your test strings and the fact we are now working back from the end of the string towards the beginning) and so, being a negative lookahead, turn this into a "success" and retry the ".aspx" sequence.
Again, given your test strings, it will repeat this process 4 times until it releases the ".aspx" at the end of each string and so finally matches on the last part of the pattern and declares a match overall.
The end result is that the negative lookahead is effectively useless - even if it does backtrack to the point where the sequences will match (and therefore return a "fail" - negative lookarounds are a bit confusing to describe!) all that will happen is that it will force another backtrack to release the character before the "/Lists/" which will mean the subsequent negative lookahead will not match (i.e. succeed) and so the overall matching process will continue.
Regex engines always work one character at a time. (If you understand such things, they are based on non-deterministic finite state automata [some regex variants are deterministic] with each state transition being driven by the next character in the input string). This means that it will only consider some part of the pattern based on the next character in the input string and where it is currently working within the pattern. I think you were trying to say "match everything with '(.+)' but reject it if you ever find a "/lists/" sequence as you go".
A lookahead (or lookbehind), whether positive or negative, only works based on the starting point of the current place within the input string. Lookarounds are one of the "anchors" that many regex engines use to test the character sequences around the current text position without changing that position. The are NOT free-ranging tests to see if the matching sequence occurs anywhere before or after the current point.
Susan