Evaluate a Python Integer Expression

Given a string expression, evaluate it and return its integer value.
Supported expression language
Nonnegative decimal integer literals.
Parentheses and ASCII space characters.
Unary + and -.
Binary +, -, *, //, %, and **.
Variables, function calls, strings, collections, and all other Python syntax are outside this exercise.
Evaluation rules
Parenthesized expressions are evaluated first.
** is right-associative. It binds more tightly than a unary sign on its left, so -2 ** 2 means -(2 ** 2).
Unary + and - are applied next.
*, //, and % share the next precedence level.
Binary + and - have the lowest precedence.
All supported binary operators other than ** are left-associative.
Division and modulo use Python integer semantics. The quotient a // b rounds down toward negative infinity. The remainder satisfies a == (a // b) * b + (a % b) and is either zero or has the same sign as b.

Function
evaluateExpression(expression: String) → long

Examples
Example 1
expression = "2 + 3 * 4"
return = 14
Multiplication has higher precedence than addition, so the value is 2 + 12 = 14.
Example 2
expression = "-2 ** 2 + 17 // 5"
return = -1
Exponentiation is evaluated before the unary minus, giving -(2 ** 2) = -4. Also, 17 // 5 = 3, so the result is -4 + 3 = -1.
Example 3
expression = "(-7) % 3 + 2 ** 3 ** 2"
return = 514
Python modulo gives (-7) % 3 = 2. Exponentiation is right-associative, so 2 ** 3 ** 2 = 2 ** 9 = 512. The total is 514.
Example 4
expression = "18 // -5 + 18 % -5"
return = -6
Python floor division gives 18 // -5 = -4, and the matching remainder is 18 % -5 = -2. Their sum is -6.

Constraints
1 <= expression.length <= 2000.
expression is syntactically valid under the supported grammar.
Every divisor is nonzero.
Every exponent is a nonnegative integer.
Every integer literal, intermediate arithmetic result, and the final result fits in a signed 64-bit integer.

The trick is a precedence-climbing or recursive descent parser with one function per level: add/sub, then mul/floordiv/mod, then unary, then power, then atom. The key detail is that power sits below unary in the call chain, so -2 ** 2 parses as -(2 ** 2). Power's right side calls unary again, so 2 ** -1 style input and chains like 2 ** 3 ** 2 resolve right-associatively. The common pitfall is language arithmetic. In Java or C++, / and % truncate toward zero, so 18 // -5 gives -3 instead of -4. You must write floor division and modulo by hand, adjusting when the remainder is nonzero and signs differ. Also compute ** with fast exponentiation, and tokenize multi-digit numbers while skipping spaces. Values fit in 64 bits, so long is enough. If the grammar slips away mid-assessment, StealthCoder is the hedge that hands you the structure while you type.

Drill it cold or hedge it with StealthCoder. Either way, don't walk into the OA hoping you remember the trick.