docs: function parseBinaryExpression() {
          var marker, markers, expr, token, prec, stack, right, operator, left, i;
  
          marker = lookahead;
          left = parseUnaryExpression();
  
          token = lookahead;
          prec = binaryPrecedence(token, state.allowIn);
          if (prec === 0) {
              return left;
          }
          token.prec = prec;
          lex();
  
          markers = [marker, lookahead];
          right = parseUnaryExpression();
  
          stack = [left, token, right];
  
          while ((prec = binaryPrecedence(lookahead, state.allowIn)) > 0) {
  
              // Reduce: make a binary expression from the three topmost entries.
              while ((stack.length > 2) && (prec <= stack[stack.length - 2].prec)) {
                  right = stack.pop();
                  operator = stack.pop().value;
                  left = stack.pop();
                  markers.pop();
                  expr = new WrappingNode(markers[markers.length - 1]).finishBinaryExpression(operator, left, right);
                  stack.push(expr);
              }
  
              // Shift.
              token = lex();
              token.prec = prec;
              stack.push(token);
              markers.push(lookahead);
              expr = parseUnaryExpression();
              stack.push(expr);
          }
  
          // Final reduce to clean-up the stack.
          i = stack.length - 1;
          expr = stack[i];
          markers.pop();
          while (i > 1) {
              expr = new WrappingNode(markers.pop()).finishBinaryExpression(stack[i - 1].value, stack[i - 2], expr);
              i -= 2;
          }
  
          return expr;
      }