Infix to Postfix converter and Postfix calculator

<!DOCTYPE html>
<html>
<head>
	<meta charset="utf-8">
	<link rel="stylesheet" href="main.css">
    <script src="https://code.jquery.com/jquery-2.2.2.min.js" integrity="sha256-36cp2Co+/62rEAAYHLmRCPIych47CvdM+uTBJwSzWjI=" crossorigin="anonymous"></script>
	<script src="common.js"></script>
    <script src="infix.js"></script>
    <script src="postfix.js"></script>
    <script src="main.js"></script>
</head>
<body>
	<h1>Infix to Postfix - Calculator</h1>
	<div>
        <div>
            <input type="text" value="2 * 5 + 3 - 2 * (8 / (4 / 2)) + (3 * 3)" id="expression" />
            <button type="button" id="btnCalc">Calculate</button>
        </div>
        <div class="hide">
            Postfix expression: <span id="spanPostfix"></span>
        </div>
        <div>
            <h3>Result:</h3>
            <span id="spanResult"></span>
        </div>
	</div>
</body>
</html>

Infix to Postfix converter and Postfix calculator

See more about the project on my http://www.ivansivak.net/blog/simple-math-evaluator-infix-to-postfix-converter-and-calculator-reverse-polish-notation

var Common = (function(){
    
	var tokenType = { operand: 1, operator: 2, leftPar: 3, rightPar: 4 },
        operators = ['+', '-', '*', '/'];
    
    var determineToken = function (char) {
        if (~operators.indexOf(char)) return tokenType.operator;

        switch (char) {
            case '(':
                return tokenType.leftPar;
            case ')':
                return tokenType.rightPar;
            default:
                return tokenType.operand;
        }
    };
    
    var trimSpaces = function (str) {
        return str.replace(/\s+/g, '');
    };
    
    var tokenize = function (str) {
        var num = '',
            res = [];
        
        for (var i = 0; i < str.length; i++){
            switch (Common.determineToken(str[i])) {
                case Common.tokenType.operand:
                    num += $.trim(str[i]);
                    break;
                case Common.tokenType.operator:
                    if ($.isNumeric(num)) res.push(parseFloat(num));
                    res.push(str[i]);
                    num = '';
                    break;
                case Common.tokenType.leftPar:
                case Common.tokenType.rightPar:
                    if ($.isNumeric(num)) res.push(parseFloat(num));
                    res.push(str[i]);
                    num = '';
                    break;
            }
        }
        if (num != '') res.push(num);
        return res;
    }
    
    return {
        tokenType: tokenType,
        determineToken: determineToken,
        trimSpaces: trimSpaces,
        tokenize: tokenize
    }
})();

/**
 * Examples:
 * ============================================
 * 2*3-4/5 = 23*45/-
 * 5+3*2 = 5 3 2*+
 * 10 + 3 * 5 / (16 - 4) = 10 3 5 * 16 4 - / +
 * 2 * 5 + 3 - 2 * (8 / (4 / 2)) + (3 * 3) = 2 5 * 3 + 2 8 4 2 / / * - 3 3 * + 
 */ 

var Infix = (function () {
    var postfix,
        stack;

    var precedence = function (operator) {
        switch (operator) {
            case '*':
            case '/':
                return 3;
            case '+':
            case '-':
                return 2;
            case '(':
                return 1;
        }
    };

    var processOperand = function (char) {
        postfix += char + ' ';
    };

    var processOperator = function (char) {
        while (stack.length > 0 &&
            (precedence(stack[stack.length - 1]) >= precedence(char))) {
            postfix += stack.pop() + ' ';
        }
        stack.push(char);
    };

    var processLeftPar = function (char) {
        stack.push(char);
    };

    var processRightPar = function (char) {
        var j = stack.length - 1,
            ce;
        while (true) {
            ce = stack.pop();
            if (ce == '(') break;

            postfix += ce + ' ';
        }
    };

    var processToken = function (char) {
        var type = Common.determineToken(char);

        switch (type) {
            case Common.tokenType.operand:
                processOperand(char);
                break;
            case Common.tokenType.operator:
                processOperator(char);
                break;
            case Common.tokenType.leftPar:
                processLeftPar(char);
                break;
            case Common.tokenType.rightPar:
                processRightPar(char);
                break;
        }
    };

    var start = function (infix) {
        var tokens = Common.tokenize(infix);
        for (var i = 0; i < tokens.length; i++) {
            processToken(tokens[i]);
        }
        return postfix;
    };

    var toPostfix = function (infix) {
        postfix = '';
        stack = [];
        stack.push('(');
        return start(infix + ')');
    };

    return {
        toPostfix: toPostfix
    }

})();

//http://www.ivansivak.net/blog/simple-math-evaluator-infix-to-postfix-converter-and-calculator-reverse-polish-notation

$(document).ready(function () {
    $('#btnCalc').click(function () {
        var infix = $('#expression').val(),
            postfix = Infix.toPostfix(infix);
            
        $('#spanPostfix').text(postfix).parent().fadeIn();
        $('#spanResult').text(Postfix.calc(postfix));
    });
});

#spanResult{
    font-size: 16px;
    font-weight: bold;
    color: rgb(teal);
}
.hide{
    display: none;
}
input[type="text"]{
    width: 250px;    
}

var Postfix = (function () {
    var stack = [];
    
    var processOperand = function (char) {
        stack.push(parseFloat(char));
    };

    var processOperator = function (char) {
        var right = (stack.pop()),
            left = (stack.pop());
            
        switch (char) {
            case '+':
                stack.push(left + right);
                break;
            case '-':
                stack.push(left - right);
                break;
            case '*':
                stack.push(left * right);
                break;
            case '/':
                stack.push(left / right);
                break;
        }
    };
    
    var processToken = function (char) {
        var type = Common.determineToken(char);

        switch (type) {
            case Common.tokenType.operand:
                processOperand(char);
                break;
            case Common.tokenType.operator:
                processOperator(char);
                break;
        }
    };
    
    var calc = function (postfix) {
        var tokens;
        
        stack = [];
        tokens = postfix.split(' ');
        tokens.splice(tokens.length - 1, 1);
        
        for (var i = 0; i < tokens.length; i++) {
            processToken(tokens[i]);
        }
        
        return stack.pop();
    };
    
    return {
        calc: calc
    }
})();