// Check the precedence to see if we can "take" the operator.
// When the precedence is too high, we'll need to build up a right-heavy 
// expression by calling ourselves recursively below.
// Otherwise, we'll return the current node to our caller so that they can
// build a left-heavy expression using the current node as a right operand.
if (newPrecedence <= precedence) {
    // For left-associative operators, a caller can only accumulate left-heavy expressions
    // like this if the new precedence is less than or equal to than the current one.
    // However, for right-associative operators (i.e. the ** operator), the new operator's
    // precedence needs to be strictly less, since something like  a ** b ** c needs to be
    // parsed as the right-heavy expression a ** (b ** c).
    //
    // Here we ensure that only if the new operator is right-associative do we
    // check for strict equality on precedence.
    if (token !== SyntaxKind.AsteriskAsteriskToken || newPrecedence < precedence) {
        break;
    }
}

if(newPrecenden <= precendence) {
    break;
}

a * b - c

token !== SyntaxKind.AsteriskAsteriskToken || newPrecedence < precedence

const canTakeNextOperator = token === SyntaxKind.AsteriskAsteriskToken ? 
    newPrecedence < precedence :
    newPrecedence <= precedence;