@openeo/js-client 2.5.0 → 2.6.0

package/src/builder/tapdigit.js

@@ -1,489 +1,489 @@
-/*
-  Copyright (C) 2011 Ariya Hidayat <ariya.hidayat@gmail.com>
-  Copyright (C) 2010 Ariya Hidayat <ariya.hidayat@gmail.com>
-
-  Redistribution and use in source and binary forms, with or without
-  modification, are permitted provided that the following conditions are met:
-
-    * Redistributions of source code must retain the above copyright
-      notice, this list of conditions and the following disclaimer.
-    * Redistributions in binary form must reproduce the above copyright
-      notice, this list of conditions and the following disclaimer in the
-      documentation and/or other materials provided with the distribution.
-    * Neither the name of the <organization> nor the
-      names of its contributors may be used to endorse or promote products
-      derived from this software without specific prior written permission.
-
-  THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS"
-  AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
-  IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
-  ARE DISCLAIMED. IN NO EVENT SHALL <COPYRIGHT HOLDER> BE LIABLE FOR ANY
-  DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
-  (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
-  LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND
-  ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
-  (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF
-  THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
-*/
-
-/* eslint-disable jsdoc/require-jsdoc */
-/**
- * @ignore
- */
-let TapDigit = {
-    Token: {
-        Operator: 'Operator',
-        Identifier: 'Identifier',
-        Number: 'Number'
-    }
-};
-
-const SUP_MAPPING = {
-    '⁰': 0,
-    '¹': 1,
-    '²': 2,
-    '³': 3,
-    '⁴': 4,
-    '⁵': 5,
-    '⁶': 6,
-    '⁷': 7,
-    '⁸': 8,
-    '⁹': 9
-};
-const SUP_STRING = Object.keys(SUP_MAPPING).join('');
-
-TapDigit.Lexer = function () {
-    let expression = '',
-        length = 0,
-        index = 0,
-        marker = 0,
-        T = TapDigit.Token;
-
-    function peekNextChar() {
-        let idx = index;
-        return ((idx < length) ? expression.charAt(idx) : '\x00');
-    }
-
-    function getNextChar() {
-        let ch = '\x00',
-            idx = index;
-        if (idx < length) {
-            ch = expression.charAt(idx);
-            index += 1;
-        }
-        return ch;
-    }
-
-    function isWhiteSpace(ch) {
-        return (ch === '\u0009') || (ch === ' ') || (ch === '\u00A0');
-    }
-
-    function isLetter(ch) {
-        return (ch >= 'a' && ch <= 'z') || (ch >= 'A' && ch <= 'Z');
-    }
-
-    function isDecimalDigit(ch) {
-        return (ch >= '0') && (ch <= '9');
-    }
-
-    function createToken(type, value) {
-        return {
-            type: type,
-            value: value,
-            start: marker,
-            end: index - 1
-        };
-    }
-
-    function skipSpaces() {
-        let ch;
-
-        while (index < length) {
-            ch = peekNextChar();
-            if (!isWhiteSpace(ch)) {
-                break;
-            }
-            getNextChar();
-        }
-    }
-
-    function scanOperator() {
-        let ch = peekNextChar();
-        if (('+-*/()^,' + SUP_STRING).indexOf(ch) >= 0) {
-            return createToken(T.Operator, getNextChar());
-        }
-        return undefined;
-    }
-
-    function isIdentifierStart(ch) {
-        return (ch === '_') || (ch === '#') || (ch === '$') || isLetter(ch);
-    }
-
-    function isAdditionalNamespaceChar(ch) {
-        return (ch === '-') || (ch === '.') || (ch === '~') || (ch === '@');
-    }
-
-    function isIdentifierPart(ch, ns = false) {
-        return (ch === '_') || isLetter(ch) || isDecimalDigit(ch) || (ns && isAdditionalNamespaceChar(ch));
-    }
-
-    function scanIdentifier() {
-        let startCh = peekNextChar();
-        if (!isIdentifierStart(startCh)) {
-            return undefined;
-        }
-
-        let id = getNextChar();
-        let ns = false;
-        while (true) {
-            let ch = peekNextChar();
-            // If the first character is a $, it is allowed that more $ follow directly after
-            if (startCh === '$') {
-                if (ch !== '$') {
-                    startCh = ''; // Stop allowing $ once the first non-$ has been found
-                } // else: allowed
-            }
-            else if (ch === '@') {
-                ns = true;
-            }
-            else if (!isIdentifierPart(ch, ns)) {
-                break;
-            }
-            id += getNextChar();
-        }
-
-        return createToken(T.Identifier, id);
-    }
-
-    function scanNumber() {
-        let ch;
-        let number;
-
-        ch = peekNextChar();
-        if (!isDecimalDigit(ch) && (ch !== '.')) {
-            return undefined;
-        }
-
-        number = '';
-        if (ch !== '.') {
-            number = getNextChar();
-            while (true) {
-                ch = peekNextChar();
-                if (!isDecimalDigit(ch)) {
-                    break;
-                }
-                number += getNextChar();
-            }
-        }
-
-        if (ch === '.') {
-            number += getNextChar();
-            while (true) {
-                ch = peekNextChar();
-                if (!isDecimalDigit(ch)) {
-                    break;
-                }
-                number += getNextChar();
-            }
-        }
-
-        if (ch === 'e' || ch === 'E') {
-            number += getNextChar();
-            ch = peekNextChar();
-            if (ch === '+' || ch === '-' || isDecimalDigit(ch)) {
-                number += getNextChar();
-                while (true) {
-                    ch = peekNextChar();
-                    if (!isDecimalDigit(ch)) {
-                        break;
-                    }
-                    number += getNextChar();
-                }
-            } else {
-                ch = 'character ' + ch;
-                if (index >= length) {
-                    ch = '<end>';
-                }
-                throw new SyntaxError('Unexpected ' + ch + ' after the exponent sign');
-            }
-        }
-
-        if (number === '.') {
-            throw new SyntaxError('Expecting decimal digits after the dot sign');
-        }
-
-        return createToken(T.Number, number);
-    }
-
-    function reset(str) {
-        expression = str;
-        length = str.length;
-        index = 0;
-    }
-
-    function next() {
-        let token;
-
-        skipSpaces();
-        if (index >= length) {
-            return undefined;
-        }
-
-        marker = index;
-
-        token = scanNumber();
-        if (typeof token !== 'undefined') {
-            return token;
-        }
-
-        token = scanOperator();
-        if (typeof token !== 'undefined') {
-            return token;
-        }
-
-        token = scanIdentifier();
-        if (typeof token !== 'undefined') {
-            return token;
-        }
-
-
-        throw new SyntaxError('Unknown token from character ' + peekNextChar());
-    }
-
-    function peek() {
-        let token;
-        let idx = index;
-        try {
-            token = next();
-            delete token.start;
-            delete token.end;
-        } catch (e) {
-            token = undefined;
-        }
-        index = idx;
-
-        return token;
-    }
-
-    return {
-        reset: reset,
-        next: next,
-        peek: peek
-    };
-};
-
-TapDigit.Parser = function () {
-    let lexer = new TapDigit.Lexer(),
-    T = TapDigit.Token;
-
-    function matchOp(token, op) {
-        return (typeof token !== 'undefined') &&
-            token.type === T.Operator &&
-            op.includes(token.value);
-    }
-
-    // ArgumentList := Expression |
-    //                 Expression ',' ArgumentList
-    function parseArgumentList() {
-        let token;
-        let expr;
-        let args = [];
-
-        while (true) {
-            expr = parseExpression();
-            if (typeof expr === 'undefined') {
-                // @todo maybe throw exception?
-                break;
-            }
-            args.push(expr);
-            token = lexer.peek();
-            if (!matchOp(token, ',')) {
-                break;
-            }
-            lexer.next();
-        }
-
-        return args;
-    }
-
-    // FunctionCall ::= Identifier '(' ')' ||
-    //                  Identifier '(' ArgumentList ')'
-    function parseFunctionCall(name) {
-        let args = [];
-        let token = lexer.next();
-        if (!matchOp(token, '(')) {
-            throw new SyntaxError('Expecting ( in a function call "' + name + '"');
-        }
-
-        token = lexer.peek();
-        if (!matchOp(token, ')')) {
-            args = parseArgumentList();
-        }
-
-        token = lexer.next();
-        if (!matchOp(token, ')')) {
-            throw new SyntaxError('Expecting ) in a function call "' + name + '"');
-        }
-
-        return {
-            'FunctionCall' : {
-                'name': name,
-                'args': args
-            }
-        };
-    }
-
-    // Primary ::= Identifier |
-    //             Number |
-    //             '(' Expression ')' |
-    //             FunctionCall
-    function parsePrimary() {
-        let expr;
-        let token = lexer.peek();
-        if (typeof token === 'undefined') {
-            throw new SyntaxError('Unexpected termination of expression');
-        }
-
-        if (token.type === T.Identifier) {
-            token = lexer.next();
-            if (matchOp(lexer.peek(), '(')) {
-                return parseFunctionCall(token.value);
-            } else {
-                return {
-                    'Identifier': token.value
-                };
-            }
-        }
-
-        if (token.type === T.Number) {
-            token = lexer.next();
-            return {
-                'Number': token.value
-            };
-        }
-
-        if (matchOp(token, '(')) {
-            lexer.next();
-            expr = parseExpression();
-            token = lexer.next();
-            if (!matchOp(token, ')')) {
-                throw new SyntaxError('Expecting )');
-            }
-            return {
-                'Expression': expr
-            };
-        }
-
-        throw new SyntaxError('Parse error, can not process token ' + token.value);
-    }
-
-    // Unary ::= Primary |
-    //           '-' Unary
-    function parseUnary() {
-        let expr;
-        let token = lexer.peek();
-        if (matchOp(token, '-+')) {
-            token = lexer.next();
-            expr = parseUnary();
-            return {
-                'Unary': {
-                    operator: token.value,
-                    expression: expr
-                }
-            };
-        }
-
-        return parsePrimary();
-    }
-
-    function parseSuperscript(ch) {
-        if (typeof SUP_MAPPING[ch] === 'number') {
-            return {'Number': SUP_MAPPING[ch]};
-        }
-        return null;
-    }
-
-    // Power ::= Unary |
-    //           Power '^' Unary |
-    //           Power⁰¹²³⁴⁵⁶⁷⁸⁹
-    function parsePower() {
-        let expr = parseUnary();
-        let token = lexer.peek();
-        while (matchOp(token, '^' + SUP_STRING)) {
-            token = lexer.next();
-            expr = {
-                'Binary': {
-                    operator: '^',
-                    left: expr,
-                    right: token.value !== '^' ? parseSuperscript(token.value) : parseUnary()
-                }
-            };
-            token = lexer.peek();
-        }
-        return expr;
-    }
-
-    // Multiplicative ::= Power |
-    //                    Multiplicative '*' Power |
-    //                    Multiplicative '/' Power |
-    function parseMultiplicative() {
-        let expr = parsePower();
-        let token = lexer.peek();
-        while (matchOp(token, '*/')) {
-            token = lexer.next();
-            expr = {
-                'Binary': {
-                    operator: token.value,
-                    left: expr,
-                    right: parsePower()
-                }
-            };
-            token = lexer.peek();
-        }
-        return expr;
-    }
-
-    // Additive ::= Multiplicative |
-    //              Additive '+' Multiplicative |
-    //              Additive '-' Multiplicative
-    function parseAdditive() {
-        let expr = parseMultiplicative();
-        let token = lexer.peek();
-        while (matchOp(token, '+-')) {
-            token = lexer.next();
-            expr = {
-                'Binary': {
-                    operator: token.value,
-                    left: expr,
-                    right: parseMultiplicative()
-                }
-            };
-            token = lexer.peek();
-        }
-        return expr;
-    }
-
-    // Expression ::= Additive
-    function parseExpression() {
-        return parseAdditive();
-    }
-
-    function parse(expression) {
-        lexer.reset(expression);
-        let expr = parseExpression();
-        let token = lexer.next();
-        if (typeof token !== 'undefined') {
-            throw new SyntaxError('Unexpected token ' + token.value);
-        }
-
-        return {
-            'Expression': expr
-        };
-    }
-
-    return {
-        parse: parse
-    };
-};
-
-module.exports = TapDigit;
+/*
+  Copyright (C) 2011 Ariya Hidayat <ariya.hidayat@gmail.com>
+  Copyright (C) 2010 Ariya Hidayat <ariya.hidayat@gmail.com>
+
+  Redistribution and use in source and binary forms, with or without
+  modification, are permitted provided that the following conditions are met:
+
+    * Redistributions of source code must retain the above copyright
+      notice, this list of conditions and the following disclaimer.
+    * Redistributions in binary form must reproduce the above copyright
+      notice, this list of conditions and the following disclaimer in the
+      documentation and/or other materials provided with the distribution.
+    * Neither the name of the <organization> nor the
+      names of its contributors may be used to endorse or promote products
+      derived from this software without specific prior written permission.
+
+  THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS"
+  AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
+  IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
+  ARE DISCLAIMED. IN NO EVENT SHALL <COPYRIGHT HOLDER> BE LIABLE FOR ANY
+  DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
+  (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
+  LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND
+  ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+  (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF
+  THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+*/
+
+/* eslint-disable jsdoc/require-jsdoc */
+/**
+ * @ignore
+ */
+let TapDigit = {
+    Token: {
+        Operator: 'Operator',
+        Identifier: 'Identifier',
+        Number: 'Number'
+    }
+};
+
+const SUP_MAPPING = {
+    '⁰': 0,
+    '¹': 1,
+    '²': 2,
+    '³': 3,
+    '⁴': 4,
+    '⁵': 5,
+    '⁶': 6,
+    '⁷': 7,
+    '⁸': 8,
+    '⁹': 9
+};
+const SUP_STRING = Object.keys(SUP_MAPPING).join('');
+
+TapDigit.Lexer = function () {
+    let expression = '',
+        length = 0,
+        index = 0,
+        marker = 0,
+        T = TapDigit.Token;
+
+    function peekNextChar() {
+        let idx = index;
+        return ((idx < length) ? expression.charAt(idx) : '\x00');
+    }
+
+    function getNextChar() {
+        let ch = '\x00',
+            idx = index;
+        if (idx < length) {
+            ch = expression.charAt(idx);
+            index += 1;
+        }
+        return ch;
+    }
+
+    function isWhiteSpace(ch) {
+        return (ch === '\u0009') || (ch === ' ') || (ch === '\u00A0');
+    }
+
+    function isLetter(ch) {
+        return (ch >= 'a' && ch <= 'z') || (ch >= 'A' && ch <= 'Z');
+    }
+
+    function isDecimalDigit(ch) {
+        return (ch >= '0') && (ch <= '9');
+    }
+
+    function createToken(type, value) {
+        return {
+            type: type,
+            value: value,
+            start: marker,
+            end: index - 1
+        };
+    }
+
+    function skipSpaces() {
+        let ch;
+
+        while (index < length) {
+            ch = peekNextChar();
+            if (!isWhiteSpace(ch)) {
+                break;
+            }
+            getNextChar();
+        }
+    }
+
+    function scanOperator() {
+        let ch = peekNextChar();
+        if (('+-*/()^,' + SUP_STRING).indexOf(ch) >= 0) {
+            return createToken(T.Operator, getNextChar());
+        }
+        return undefined;
+    }
+
+    function isIdentifierStart(ch) {
+        return (ch === '_') || (ch === '#') || (ch === '$') || isLetter(ch);
+    }
+
+    function isAdditionalNamespaceChar(ch) {
+        return (ch === '-') || (ch === '.') || (ch === '~') || (ch === '@');
+    }
+
+    function isIdentifierPart(ch, ns = false) {
+        return (ch === '_') || isLetter(ch) || isDecimalDigit(ch) || (ns && isAdditionalNamespaceChar(ch));
+    }
+
+    function scanIdentifier() {
+        let startCh = peekNextChar();
+        if (!isIdentifierStart(startCh)) {
+            return undefined;
+        }
+
+        let id = getNextChar();
+        let ns = false;
+        while (true) {
+            let ch = peekNextChar();
+            // If the first character is a $, it is allowed that more $ follow directly after
+            if (startCh === '$') {
+                if (ch !== '$') {
+                    startCh = ''; // Stop allowing $ once the first non-$ has been found
+                } // else: allowed
+            }
+            else if (ch === '@') {
+                ns = true;
+            }
+            else if (!isIdentifierPart(ch, ns)) {
+                break;
+            }
+            id += getNextChar();
+        }
+
+        return createToken(T.Identifier, id);
+    }
+
+    function scanNumber() {
+        let ch;
+        let number;
+
+        ch = peekNextChar();
+        if (!isDecimalDigit(ch) && (ch !== '.')) {
+            return undefined;
+        }
+
+        number = '';
+        if (ch !== '.') {
+            number = getNextChar();
+            while (true) {
+                ch = peekNextChar();
+                if (!isDecimalDigit(ch)) {
+                    break;
+                }
+                number += getNextChar();
+            }
+        }
+
+        if (ch === '.') {
+            number += getNextChar();
+            while (true) {
+                ch = peekNextChar();
+                if (!isDecimalDigit(ch)) {
+                    break;
+                }
+                number += getNextChar();
+            }
+        }
+
+        if (ch === 'e' || ch === 'E') {
+            number += getNextChar();
+            ch = peekNextChar();
+            if (ch === '+' || ch === '-' || isDecimalDigit(ch)) {
+                number += getNextChar();
+                while (true) {
+                    ch = peekNextChar();
+                    if (!isDecimalDigit(ch)) {
+                        break;
+                    }
+                    number += getNextChar();
+                }
+            } else {
+                ch = 'character ' + ch;
+                if (index >= length) {
+                    ch = '<end>';
+                }
+                throw new SyntaxError('Unexpected ' + ch + ' after the exponent sign');
+            }
+        }
+
+        if (number === '.') {
+            throw new SyntaxError('Expecting decimal digits after the dot sign');
+        }
+
+        return createToken(T.Number, number);
+    }
+
+    function reset(str) {
+        expression = str;
+        length = str.length;
+        index = 0;
+    }
+
+    function next() {
+        let token;
+
+        skipSpaces();
+        if (index >= length) {
+            return undefined;
+        }
+
+        marker = index;
+
+        token = scanNumber();
+        if (typeof token !== 'undefined') {
+            return token;
+        }
+
+        token = scanOperator();
+        if (typeof token !== 'undefined') {
+            return token;
+        }
+
+        token = scanIdentifier();
+        if (typeof token !== 'undefined') {
+            return token;
+        }
+
+
+        throw new SyntaxError('Unknown token from character ' + peekNextChar());
+    }
+
+    function peek() {
+        let token;
+        let idx = index;
+        try {
+            token = next();
+            delete token.start;
+            delete token.end;
+        } catch (e) {
+            token = undefined;
+        }
+        index = idx;
+
+        return token;
+    }
+
+    return {
+        reset: reset,
+        next: next,
+        peek: peek
+    };
+};
+
+TapDigit.Parser = function () {
+    let lexer = new TapDigit.Lexer(),
+    T = TapDigit.Token;
+
+    function matchOp(token, op) {
+        return (typeof token !== 'undefined') &&
+            token.type === T.Operator &&
+            op.includes(token.value);
+    }
+
+    // ArgumentList := Expression |
+    //                 Expression ',' ArgumentList
+    function parseArgumentList() {
+        let token;
+        let expr;
+        let args = [];
+
+        while (true) {
+            expr = parseExpression();
+            if (typeof expr === 'undefined') {
+                // @todo maybe throw exception?
+                break;
+            }
+            args.push(expr);
+            token = lexer.peek();
+            if (!matchOp(token, ',')) {
+                break;
+            }
+            lexer.next();
+        }
+
+        return args;
+    }
+
+    // FunctionCall ::= Identifier '(' ')' ||
+    //                  Identifier '(' ArgumentList ')'
+    function parseFunctionCall(name) {
+        let args = [];
+        let token = lexer.next();
+        if (!matchOp(token, '(')) {
+            throw new SyntaxError('Expecting ( in a function call "' + name + '"');
+        }
+
+        token = lexer.peek();
+        if (!matchOp(token, ')')) {
+            args = parseArgumentList();
+        }
+
+        token = lexer.next();
+        if (!matchOp(token, ')')) {
+            throw new SyntaxError('Expecting ) in a function call "' + name + '"');
+        }
+
+        return {
+            'FunctionCall' : {
+                'name': name,
+                'args': args
+            }
+        };
+    }
+
+    // Primary ::= Identifier |
+    //             Number |
+    //             '(' Expression ')' |
+    //             FunctionCall
+    function parsePrimary() {
+        let expr;
+        let token = lexer.peek();
+        if (typeof token === 'undefined') {
+            throw new SyntaxError('Unexpected termination of expression');
+        }
+
+        if (token.type === T.Identifier) {
+            token = lexer.next();
+            if (matchOp(lexer.peek(), '(')) {
+                return parseFunctionCall(token.value);
+            } else {
+                return {
+                    'Identifier': token.value
+                };
+            }
+        }
+
+        if (token.type === T.Number) {
+            token = lexer.next();
+            return {
+                'Number': token.value
+            };
+        }
+
+        if (matchOp(token, '(')) {
+            lexer.next();
+            expr = parseExpression();
+            token = lexer.next();
+            if (!matchOp(token, ')')) {
+                throw new SyntaxError('Expecting )');
+            }
+            return {
+                'Expression': expr
+            };
+        }
+
+        throw new SyntaxError('Parse error, can not process token ' + token.value);
+    }
+
+    // Unary ::= Primary |
+    //           '-' Unary
+    function parseUnary() {
+        let expr;
+        let token = lexer.peek();
+        if (matchOp(token, '-+')) {
+            token = lexer.next();
+            expr = parseUnary();
+            return {
+                'Unary': {
+                    operator: token.value,
+                    expression: expr
+                }
+            };
+        }
+
+        return parsePrimary();
+    }
+
+    function parseSuperscript(ch) {
+        if (typeof SUP_MAPPING[ch] === 'number') {
+            return {'Number': SUP_MAPPING[ch]};
+        }
+        return null;
+    }
+
+    // Power ::= Unary |
+    //           Power '^' Unary |
+    //           Power⁰¹²³⁴⁵⁶⁷⁸⁹
+    function parsePower() {
+        let expr = parseUnary();
+        let token = lexer.peek();
+        while (matchOp(token, '^' + SUP_STRING)) {
+            token = lexer.next();
+            expr = {
+                'Binary': {
+                    operator: '^',
+                    left: expr,
+                    right: token.value !== '^' ? parseSuperscript(token.value) : parseUnary()
+                }
+            };
+            token = lexer.peek();
+        }
+        return expr;
+    }
+
+    // Multiplicative ::= Power |
+    //                    Multiplicative '*' Power |
+    //                    Multiplicative '/' Power |
+    function parseMultiplicative() {
+        let expr = parsePower();
+        let token = lexer.peek();
+        while (matchOp(token, '*/')) {
+            token = lexer.next();
+            expr = {
+                'Binary': {
+                    operator: token.value,
+                    left: expr,
+                    right: parsePower()
+                }
+            };
+            token = lexer.peek();
+        }
+        return expr;
+    }
+
+    // Additive ::= Multiplicative |
+    //              Additive '+' Multiplicative |
+    //              Additive '-' Multiplicative
+    function parseAdditive() {
+        let expr = parseMultiplicative();
+        let token = lexer.peek();
+        while (matchOp(token, '+-')) {
+            token = lexer.next();
+            expr = {
+                'Binary': {
+                    operator: token.value,
+                    left: expr,
+                    right: parseMultiplicative()
+                }
+            };
+            token = lexer.peek();
+        }
+        return expr;
+    }
+
+    // Expression ::= Additive
+    function parseExpression() {
+        return parseAdditive();
+    }
+
+    function parse(expression) {
+        lexer.reset(expression);
+        let expr = parseExpression();
+        let token = lexer.next();
+        if (typeof token !== 'undefined') {
+            throw new SyntaxError('Unexpected token ' + token.value);
+        }
+
+        return {
+            'Expression': expr
+        };
+    }
+
+    return {
+        parse: parse
+    };
+};
+
+module.exports = TapDigit;