imerss-bioinfo 1.0.0

package/src/expressions/jsep.js

@@ -0,0 +1,925 @@
+/* eslint-disable */
+
+// This file was taken from revision 25fcb53 of https://github.com/EricSmekens/jsep/blob/master/src/jsep.js
+// since we need the fix which axed "LogicalExpression" but need to defeat the insufferable ES6 modules crap
+// which prevents it from loading. The "export" keyword was removed from the top of the file and a standard
+// CJS export was put at the bottom. Probably when jsep 0.5.0 is released we can update to it
+
+//     JavaScript Expression Parser (JSEP) <%= version %>
+//     JSEP may be freely distributed under the MIT License
+//     https://ericsmekens.github.io/jsep/
+class Jsep {
+	/**
+	 * @returns {string}
+	 */
+	static get version() {
+		// To be filled in by the template
+		return '<%= version %>';
+	}
+
+	/**
+	 * @returns {string}
+	 */
+	static toString() {
+		return 'JavaScript Expression Parser (JSEP) v' + Jsep.version;
+	};
+
+	// ==================== CONFIG ================================
+	/**
+	 * @method addUnaryOp
+	 * @param {string} op_name The name of the unary op to add
+	 * @returns {Jsep}
+	 */
+	static addUnaryOp(op_name) {
+		Jsep.max_unop_len = Math.max(op_name.length, Jsep.max_unop_len);
+		Jsep.unary_ops[op_name] = 1;
+		return Jsep;
+	}
+
+	/**
+	 * @method jsep.addBinaryOp
+	 * @param {string} op_name The name of the binary op to add
+	 * @param {number} precedence The precedence of the binary op (can be a float)
+	 * @returns {Jsep}
+	 */
+	static addBinaryOp(op_name, precedence) {
+		Jsep.max_binop_len = Math.max(op_name.length, Jsep.max_binop_len);
+		Jsep.binary_ops[op_name] = precedence;
+		return Jsep;
+	}
+
+	/**
+	 * @method addIdentifierChar
+	 * @param {string} char The additional character to treat as a valid part of an identifier
+	 * @returns {Jsep}
+	 */
+	static addIdentifierChar(char) {
+		Jsep.additional_identifier_chars.add(char);
+		return Jsep;
+	}
+
+	/**
+	 * @method addLiteral
+	 * @param {string} literal_name The name of the literal to add
+	 * @param {*} literal_value The value of the literal
+	 * @returns {Jsep}
+	 */
+	static addLiteral(literal_name, literal_value) {
+		Jsep.literals[literal_name] = literal_value;
+		return Jsep;
+	}
+
+	/**
+	 * @method removeUnaryOp
+	 * @param {string} op_name The name of the unary op to remove
+	 * @returns {Jsep}
+	 */
+	static removeUnaryOp(op_name) {
+		delete Jsep.unary_ops[op_name];
+		if (op_name.length === Jsep.max_unop_len) {
+			Jsep.max_unop_len = Jsep.getMaxKeyLen(Jsep.unary_ops);
+		}
+		return Jsep;
+	}
+
+	/**
+	 * @method removeAllUnaryOps
+	 * @returns {Jsep}
+	 */
+	static removeAllUnaryOps() {
+		Jsep.unary_ops = {};
+		Jsep.max_unop_len = 0;
+
+		return Jsep;
+	}
+
+	/**
+	 * @method removeIdentifierChar
+	 * @param {string} char The additional character to stop treating as a valid part of an identifier
+	 * @returns {Jsep}
+	 */
+	static removeIdentifierChar(char) {
+		Jsep.additional_identifier_chars.delete(char);
+		return Jsep;
+	}
+
+	/**
+	 * @method removeBinaryOp
+	 * @param {string} op_name The name of the binary op to remove
+	 * @returns {Jsep}
+	 */
+	static removeBinaryOp(op_name) {
+		delete Jsep.binary_ops[op_name];
+
+		if (op_name.length === Jsep.max_binop_len) {
+			Jsep.max_binop_len = Jsep.getMaxKeyLen(Jsep.binary_ops);
+		}
+
+		return Jsep;
+	}
+
+	/**
+	 * @method removeAllBinaryOps
+	 * @returns {Jsep}
+	 */
+	static removeAllBinaryOps() {
+		Jsep.binary_ops = {};
+		Jsep.max_binop_len = 0;
+
+		return Jsep;
+	}
+
+	/**
+	 * @method removeLiteral
+	 * @param {string} literal_name The name of the literal to remove
+	 * @returns {Jsep}
+	 */
+	static removeLiteral(literal_name) {
+		delete Jsep.literals[literal_name];
+		return Jsep;
+	}
+
+	/**
+	 * @method removeAllLiterals
+	 * @returns {Jsep}
+	 */
+	static removeAllLiterals() {
+		Jsep.literals = {};
+
+		return Jsep;
+	}
+	// ==================== END CONFIG ============================
+
+
+	/**
+	 * @returns {string}
+	 */
+	get char() {
+		return this.expr.charAt(this.index);
+	}
+
+	/**
+	 * @returns {number}
+	 */
+	get code() {
+		return this.expr.charCodeAt(this.index);
+	};
+
+
+	/**
+	 * @param {string} expr a string with the passed in express
+	 * @returns Jsep
+	 */
+	constructor(expr) {
+		// `index` stores the character number we are currently at
+		// All of the gobbles below will modify `index` as we move along
+		this.expr = expr;
+		this.index = 0;
+	}
+
+	/**
+	 * static top-level parser
+	 * @returns {jsep.Expression}
+	 */
+	static parse(expr) {
+		return (new Jsep(expr)).parse();
+	}
+
+	/**
+	 * Get the longest key length of any object
+	 * @param {object} obj
+	 * @returns {number}
+	 */
+	static getMaxKeyLen(obj) {
+		return Math.max(0, ...Object.keys(obj).map(k => k.length));
+	}
+
+	/**
+	 * `ch` is a character code in the next three functions
+	 * @param {number} ch
+	 * @returns {boolean}
+	 */
+	static isDecimalDigit(ch) {
+		return (ch >= 48 && ch <= 57); // 0...9
+	}
+
+	/**
+	 * Returns the precedence of a binary operator or `0` if it isn't a binary operator. Can be float.
+	 * @param {string} op_val
+	 * @returns {number}
+	 */
+	static binaryPrecedence(op_val) {
+		return Jsep.binary_ops[op_val] || 0;
+	}
+
+	/**
+	 * Looks for start of identifier
+	 * @param {number} ch
+	 * @returns {boolean}
+	 */
+	static isIdentifierStart(ch) {
+		return  (ch >= 65 && ch <= 90) || // A...Z
+			(ch >= 97 && ch <= 122) || // a...z
+			(ch >= 128 && !Jsep.binary_ops[String.fromCharCode(ch)]) || // any non-ASCII that is not an operator
+			(Jsep.additional_identifier_chars.has(String.fromCharCode(ch))); // additional characters
+	}
+
+	/**
+	 * @param {number} ch
+	 * @returns {boolean}
+	 */
+	static isIdentifierPart(ch) {
+		return Jsep.isIdentifierStart(ch) || Jsep.isDecimalDigit(ch);
+	}
+
+	/**
+	 * throw error at index of the expression
+	 * @param {string} message
+	 * @throws
+	 */
+	throwError(message) {
+		const error = new Error(message + ' at character ' + this.index);
+		error.index = this.index;
+		error.description = message;
+		throw error;
+	}
+
+	/**
+	 * Push `index` up to the next non-space character
+	 */
+	gobbleSpaces() {
+		let ch = this.code;
+		// Whitespace
+		while (ch === Jsep.SPACE_CODE
+		|| ch === Jsep.TAB_CODE
+		|| ch === Jsep.LF_CODE
+		|| ch === Jsep.CR_CODE) {
+			ch = this.expr.charCodeAt(++this.index);
+		}
+	}
+
+	/**
+	 * Top-level method to parse all expressions and returns compound or single node
+	 * @returns {jsep.Expression}
+	 */
+	parse() {
+		const nodes = this.gobbleExpressions();
+
+		// If there's only one expression just try returning the expression
+		if (nodes.length === 1) {
+			return nodes[0];
+		}
+		else {
+			return {
+				type: Jsep.COMPOUND,
+				body: nodes
+			};
+		}
+	}
+
+	/**
+	 * top-level parser (but can be reused within as well)
+	 * @param {number} [untilICode]
+	 * @returns {jsep.Expression[]}
+	 */
+	gobbleExpressions(untilICode) {
+		let nodes = [], ch_i, node;
+
+		while (this.index < this.expr.length) {
+			ch_i = this.code;
+
+			// Expressions can be separated by semicolons, commas, or just inferred without any
+			// separators
+			if (ch_i === Jsep.SEMCOL_CODE || ch_i === Jsep.COMMA_CODE) {
+				this.index++; // ignore separators
+			}
+			else {
+				// Try to gobble each expression individually
+				if (node = this.gobbleExpression()) {
+					nodes.push(node);
+					// If we weren't able to find a binary expression and are out of room, then
+					// the expression passed in probably has too much
+				}
+				else if (this.index < this.expr.length) {
+					if (ch_i === untilICode) {
+						break;
+					}
+					this.throwError('Unexpected "' + this.char + '"');
+				}
+			}
+		}
+
+		return nodes;
+	}
+
+	//
+	/**
+	 * The main parsing function. Much of this code is dedicated to ternary expressions
+	 * @returns {?jsep.Expression}
+	 */
+	gobbleExpression() {
+		const test = this.gobbleBinaryExpression();
+
+		this.gobbleSpaces();
+
+		if (this.code === Jsep.QUMARK_CODE) {
+			// Ternary expression: test ? consequent : alternate
+			this.index++;
+			const consequent = this.gobbleExpression();
+
+			if (!consequent) {
+				this.throwError('Expected expression');
+			}
+
+			this.gobbleSpaces();
+
+			if (this.code === Jsep.COLON_CODE) {
+				this.index++;
+				const alternate = this.gobbleExpression();
+
+				if (!alternate) {
+					this.throwError('Expected expression');
+				}
+				return {
+					type: Jsep.CONDITIONAL_EXP,
+					test,
+					consequent,
+					alternate
+				};
+			}
+			else {
+				this.throwError('Expected :');
+			}
+		}
+		else {
+			return test;
+		}
+	}
+
+	/**
+	 * Search for the operation portion of the string (e.g. `+`, `===`)
+	 * Start by taking the longest possible binary operations (3 characters: `===`, `!==`, `>>>`)
+	 * and move down from 3 to 2 to 1 character until a matching binary operation is found
+	 * then, return that binary operation
+	 * @returns {string|boolean}
+	 */
+	gobbleBinaryOp() {
+		this.gobbleSpaces();
+		let to_check = this.expr.substr(this.index, Jsep.max_binop_len);
+		let tc_len = to_check.length;
+
+		while (tc_len > 0) {
+			// Don't accept a binary op when it is an identifier.
+			// Binary ops that start with a identifier-valid character must be followed
+			// by a non identifier-part valid character
+			if (Jsep.binary_ops.hasOwnProperty(to_check) && (
+				!Jsep.isIdentifierStart(this.code) ||
+				(this.index + to_check.length < this.expr.length && !Jsep.isIdentifierPart(this.expr.charCodeAt(this.index + to_check.length)))
+			)) {
+				this.index += tc_len;
+				return to_check;
+			}
+			to_check = to_check.substr(0, --tc_len);
+		}
+		return false;
+	}
+
+	/**
+	 * This function is responsible for gobbling an individual expression,
+	 * e.g. `1`, `1+2`, `a+(b*2)-Math.sqrt(2)`
+	 * @returns {?jsep.BinaryExpression}
+	 */
+	gobbleBinaryExpression() {
+		let node, biop, prec, stack, biop_info, left, right, i, cur_biop;
+
+		// First, try to get the leftmost thing
+		// Then, check to see if there's a binary operator operating on that leftmost thing
+		left = this.gobbleToken();
+		biop = this.gobbleBinaryOp();
+
+		// If there wasn't a binary operator, just return the leftmost node
+		if (!biop) {
+			return left;
+		}
+
+		// Otherwise, we need to start a stack to properly place the binary operations in their
+		// precedence structure
+		biop_info = { value: biop, prec: Jsep.binaryPrecedence(biop)};
+
+		right = this.gobbleToken();
+
+		if (!right) {
+			this.throwError("Expected expression after " + biop);
+		}
+
+		stack = [left, biop_info, right];
+
+		// Properly deal with precedence using [recursive descent](http://www.engr.mun.ca/~theo/Misc/exp_parsing.htm)
+		while ((biop = this.gobbleBinaryOp())) {
+			prec = Jsep.binaryPrecedence(biop);
+
+			if (prec === 0) {
+				this.index -= biop.length;
+				break;
+			}
+
+			biop_info = { value: biop, prec };
+
+			cur_biop = biop;
+
+			// Reduce: make a binary expression from the three topmost entries.
+			while ((stack.length > 2) && (prec <= stack[stack.length - 2].prec)) {
+				right = stack.pop();
+				biop = stack.pop().value;
+				left = stack.pop();
+				node = {
+					type: Jsep.BINARY_EXP,
+					operator: biop,
+					left,
+					right
+				};
+				stack.push(node);
+			}
+
+			node = this.gobbleToken();
+
+			if (!node) {
+				this.throwError("Expected expression after " + cur_biop);
+			}
+
+			stack.push(biop_info, node);
+		}
+
+		i = stack.length - 1;
+		node = stack[i];
+
+		while (i > 1) {
+			node = {
+				type: Jsep.BINARY_EXP,
+				operator: stack[i - 1].value,
+				left: stack[i - 2],
+				right: node
+			};
+			i -= 2;
+		}
+
+		return node;
+	}
+
+	/**
+	 * An individual part of a binary expression:
+	 * e.g. `foo.bar(baz)`, `1`, `"abc"`, `(a % 2)` (because it's in parenthesis)
+	 * @returns {boolean|jsep.Expression}
+	 */
+	gobbleToken() {
+		let ch, to_check, tc_len, node;
+
+		this.gobbleSpaces();
+		ch = this.code;
+
+		if (Jsep.isDecimalDigit(ch) || ch === Jsep.PERIOD_CODE) {
+			// Char code 46 is a dot `.` which can start off a numeric literal
+			return this.gobbleNumericLiteral();
+		}
+
+		if (ch === Jsep.SQUOTE_CODE || ch === Jsep.DQUOTE_CODE) {
+			// Single or double quotes
+			node = this.gobbleStringLiteral();
+		}
+		else if (ch === Jsep.OBRACK_CODE) {
+			node = this.gobbleArray();
+		}
+		else {
+			to_check = this.expr.substr(this.index, Jsep.max_unop_len);
+			tc_len = to_check.length;
+
+			while (tc_len > 0) {
+				// Don't accept an unary op when it is an identifier.
+				// Unary ops that start with a identifier-valid character must be followed
+				// by a non identifier-part valid character
+				if (Jsep.unary_ops.hasOwnProperty(to_check) && (
+					!Jsep.isIdentifierStart(this.code) ||
+					(this.index + to_check.length < this.expr.length && !Jsep.isIdentifierPart(this.expr.charCodeAt(this.index + to_check.length)))
+				)) {
+					this.index += tc_len;
+					return {
+						type: Jsep.UNARY_EXP,
+						operator: to_check,
+						argument: this.gobbleToken(),
+						prefix: true
+					};
+				}
+
+				to_check = to_check.substr(0, --tc_len);
+			}
+
+			if (Jsep.isIdentifierStart(ch)) {
+				node = this.gobbleIdentifier();
+			}
+			else if (ch === Jsep.OPAREN_CODE) { // open parenthesis
+				node = this.gobbleGroup();
+			}
+		}
+
+		if (!node) {
+			return false;
+		}
+
+		this.gobbleSpaces();
+
+		ch = this.code;
+
+		// Gobble properties of of identifiers/strings/arrays/groups.
+		// e.g. `foo`, `bar.baz`, `foo['bar'].baz`
+		// It also gobbles function calls:
+		// e.g. `Math.acos(obj.angle)`
+
+		while (ch === Jsep.PERIOD_CODE || ch === Jsep.OBRACK_CODE || ch === Jsep.OPAREN_CODE) {
+			this.index++;
+
+			if (ch === Jsep.PERIOD_CODE) {
+				this.gobbleSpaces();
+				node = {
+					type: Jsep.MEMBER_EXP,
+					computed: false,
+					object: node,
+					property: this.gobbleIdentifier()
+				};
+			}
+			else if (ch === Jsep.OBRACK_CODE) {
+				node = {
+					type: Jsep.MEMBER_EXP,
+					computed: true,
+					object: node,
+					property: this.gobbleExpression()
+				};
+				this.gobbleSpaces();
+				ch = this.code;
+				if (ch !== Jsep.CBRACK_CODE) {
+					this.throwError('Unclosed [');
+				}
+				this.index++;
+			}
+			else if (ch === Jsep.OPAREN_CODE) {
+				// A function call is being made; gobble all the arguments
+				node = {
+					type: Jsep.CALL_EXP,
+					'arguments': this.gobbleArguments(Jsep.CPAREN_CODE),
+					callee: node
+				};
+			}
+			this.gobbleSpaces();
+			ch = this.code;
+		}
+
+		return node;
+	}
+
+	/**
+	 * Parse simple numeric literals: `12`, `3.4`, `.5`. Do this by using a string to
+	 * keep track of everything in the numeric literal and then calling `parseFloat` on that string
+	 * @returns {jsep.Literal}
+	 */
+	gobbleNumericLiteral() {
+		let number = '', ch, chCode;
+
+		while (Jsep.isDecimalDigit(this.code)) {
+			number += this.expr.charAt(this.index++);
+		}
+
+		if (this.code === Jsep.PERIOD_CODE) { // can start with a decimal marker
+			number += this.expr.charAt(this.index++);
+
+			while (Jsep.isDecimalDigit(this.code)) {
+				number += this.expr.charAt(this.index++);
+			}
+		}
+
+		ch = this.char;
+
+		if (ch === 'e' || ch === 'E') { // exponent marker
+			number += this.expr.charAt(this.index++);
+			ch = this.char;
+
+			if (ch === '+' || ch === '-') { // exponent sign
+				number += this.expr.charAt(this.index++);
+			}
+
+			while (Jsep.isDecimalDigit(this.code)) { // exponent itself
+				number += this.expr.charAt(this.index++);
+			}
+
+			if (!Jsep.isDecimalDigit(this.expr.charCodeAt(this.index - 1)) ) {
+				this.throwError('Expected exponent (' + number + this.char + ')');
+			}
+		}
+
+		chCode = this.code;
+
+		// Check to make sure this isn't a variable name that start with a number (123abc)
+		if (Jsep.isIdentifierStart(chCode)) {
+			this.throwError('Variable names cannot start with a number (' +
+				number + this.char + ')');
+		}
+		else if (chCode === Jsep.PERIOD_CODE) {
+			this.throwError('Unexpected period');
+		}
+
+		return {
+			type: Jsep.LITERAL,
+			value: parseFloat(number),
+			raw: number
+		};
+	}
+
+	/**
+	 * Parses a string literal, staring with single or double quotes with basic support for escape codes
+	 * e.g. `"hello world"`, `'this is\nJSEP'`
+	 * @returns {jsep.Literal}
+	 */
+	gobbleStringLiteral() {
+		let str = '';
+		let quote = this.expr.charAt(this.index++);
+		let closed = false;
+
+		while (this.index < this.expr.length) {
+			let ch = this.expr.charAt(this.index++);
+
+			if (ch === quote) {
+				closed = true;
+				break;
+			}
+			else if (ch === '\\') {
+				// Check for all of the common escape codes
+				ch = this.expr.charAt(this.index++);
+
+				switch (ch) {
+					case 'n': str += '\n'; break;
+					case 'r': str += '\r'; break;
+					case 't': str += '\t'; break;
+					case 'b': str += '\b'; break;
+					case 'f': str += '\f'; break;
+					case 'v': str += '\x0B'; break;
+					default : str += ch;
+				}
+			}
+			else {
+				str += ch;
+			}
+		}
+
+		if (!closed) {
+			this.throwError('Unclosed quote after "' + str + '"');
+		}
+
+		return {
+			type: Jsep.LITERAL,
+			value: str,
+			raw: quote + str + quote
+		};
+	}
+
+	/**
+	 * Gobbles only identifiers
+	 * e.g.: `foo`, `_value`, `$x1`
+	 * Also, this function checks if that identifier is a literal:
+	 * (e.g. `true`, `false`, `null`) or `this`
+	 * @returns {jsep.Expression}
+	 */
+	gobbleIdentifier() {
+		let ch = this.code, start = this.index, identifier;
+
+		if (Jsep.isIdentifierStart(ch)) {
+			this.index++;
+		}
+		else {
+			this.throwError('Unexpected ' + this.char);
+		}
+
+		while (this.index < this.expr.length) {
+			ch = this.code;
+
+			if (Jsep.isIdentifierPart(ch)) {
+				this.index++;
+			}
+			else {
+				break;
+			}
+		}
+		identifier = this.expr.slice(start, this.index);
+
+		if (Jsep.literals.hasOwnProperty(identifier)) {
+			return {
+				type: Jsep.LITERAL,
+				value: Jsep.literals[identifier],
+				raw: identifier
+			};
+		}
+		else if (identifier === Jsep.this_str) {
+			return { type: Jsep.THIS_EXP };
+		}
+		else {
+			return {
+				type: Jsep.IDENTIFIER,
+				name: identifier
+			};
+		}
+	}
+
+	/**
+	 * Gobbles a list of arguments within the context of a function call
+	 * or array literal. This function also assumes that the opening character
+	 * `(` or `[` has already been gobbled, and gobbles expressions and commas
+	 * until the terminator character `)` or `]` is encountered.
+	 * e.g. `foo(bar, baz)`, `my_func()`, or `[bar, baz]`
+	 * @param {string} termination
+	 * @returns {jsep.Expression[]}
+	 */
+	gobbleArguments(termination) {
+		const args = [];
+		let closed = false;
+		let separator_count = 0;
+
+		while (this.index < this.expr.length) {
+			this.gobbleSpaces();
+			let ch_i = this.code;
+
+			if (ch_i === termination) { // done parsing
+				closed = true;
+				this.index++;
+
+				if (termination === Jsep.CPAREN_CODE && separator_count && separator_count >= args.length){
+					this.throwError('Unexpected token ' + String.fromCharCode(termination));
+				}
+
+				break;
+			}
+			else if (ch_i === Jsep.COMMA_CODE) { // between expressions
+				this.index++;
+				separator_count++;
+
+				if (separator_count !== args.length) { // missing argument
+					if (termination === Jsep.CPAREN_CODE) {
+						this.throwError('Unexpected token ,');
+					}
+					else if (termination === Jsep.CBRACK_CODE) {
+						for (let arg = args.length; arg < separator_count; arg++) {
+							args.push(null);
+						}
+					}
+				}
+			}
+			else {
+				const node = this.gobbleExpression();
+
+				if (!node || node.type === Jsep.COMPOUND) {
+					this.throwError('Expected comma');
+				}
+
+				args.push(node);
+			}
+		}
+
+		if (!closed) {
+			this.throwError('Expected ' + String.fromCharCode(termination));
+		}
+
+		return args;
+	}
+
+	/**
+	 * Responsible for parsing a group of things within parentheses `()`
+	 * that have no identifier in front (so not a function call)
+	 * This function assumes that it needs to gobble the opening parenthesis
+	 * and then tries to gobble everything within that parenthesis, assuming
+	 * that the next thing it should see is the close parenthesis. If not,
+	 * then the expression probably doesn't have a `)`
+	 * @returns {boolean|jsep.Expression}
+	 */
+	gobbleGroup() {
+		this.index++;
+		let nodes = this.gobbleExpressions(Jsep.CPAREN_CODE);
+		if (this.code === Jsep.CPAREN_CODE) {
+			this.index++;
+			if (nodes.length === 1) {
+				return nodes[0];
+			}
+			else if (!nodes.length) {
+				return false;
+			}
+			else {
+				return {
+					type: Jsep.SEQUENCE_EXP,
+					expressions: nodes,
+				};
+			}
+		}
+		else {
+			this.throwError('Unclosed (');
+		}
+	}
+
+	/**
+	 * Responsible for parsing Array literals `[1, 2, 3]`
+	 * This function assumes that it needs to gobble the opening bracket
+	 * and then tries to gobble the expressions as arguments.
+	 * @returns {jsep.ArrayExpression}
+	 */
+	gobbleArray() {
+		this.index++;
+
+		return {
+			type: Jsep.ARRAY_EXP,
+			elements: this.gobbleArguments(Jsep.CBRACK_CODE)
+		};
+	}
+}
+
+// Backward Compatibility (before adding the static fields):
+const jsep = expr => (new Jsep(expr)).parse();
+const staticMethods = Object.getOwnPropertyNames(Jsep);
+staticMethods
+	.slice(staticMethods.indexOf('version'), staticMethods.indexOf('removeAllLiterals') + 1)
+	.forEach((m) => {
+		jsep[m] = Jsep[m];
+	});
+// export default jsep;
+
+
+// Static fields:
+Object.assign(Jsep, {
+	// Node Types
+	// ----------
+	// This is the full set of types that any JSEP node can be.
+	// Store them here to save space when minified
+	COMPOUND:        'Compound',
+	SEQUENCE_EXP:    'SequenceExpression',
+	IDENTIFIER:      'Identifier',
+	MEMBER_EXP:      'MemberExpression',
+	LITERAL:         'Literal',
+	THIS_EXP:        'ThisExpression',
+	CALL_EXP:        'CallExpression',
+	UNARY_EXP:       'UnaryExpression',
+	BINARY_EXP:      'BinaryExpression',
+	CONDITIONAL_EXP: 'ConditionalExpression',
+	ARRAY_EXP:       'ArrayExpression',
+
+	TAB_CODE:    9,
+	LF_CODE:     10,
+	CR_CODE:     13,
+	SPACE_CODE:  32,
+	PERIOD_CODE: 46, // '.'
+	COMMA_CODE:  44, // ','
+	SQUOTE_CODE: 39, // single quote
+	DQUOTE_CODE: 34, // double quotes
+	OPAREN_CODE: 40, // (
+	CPAREN_CODE: 41, // )
+	OBRACK_CODE: 91, // [
+	CBRACK_CODE: 93, // ]
+	QUMARK_CODE: 63, // ?
+	SEMCOL_CODE: 59, // ;
+	COLON_CODE:  58, // :
+
+
+	// Operations
+	// ----------
+	// Use a quickly-accessible map to store all of the unary operators
+	// Values are set to `1` (it really doesn't matter)
+	unary_ops: {
+		'-': 1,
+		'!': 1,
+		'~': 1,
+		'+': 1
+	},
+
+	// Also use a map for the binary operations but set their values to their
+	// binary precedence for quick reference:
+	// see [Order of operations](http://en.wikipedia.org/wiki/Order_of_operations#Programming_language)
+	binary_ops: {
+		'||': 1, '&&': 2, '|': 3, '^': 4, '&': 5,
+		'==': 6, '!=': 6, '===': 6, '!==': 6,
+		'<': 7, '>': 7, '<=': 7, '>=': 7,
+		'<<': 8, '>>': 8, '>>>': 8,
+		'+': 9, '-': 9,
+		'*': 10, '/': 10, '%': 10
+	},
+
+	// Additional valid identifier chars, apart from a-z, A-Z and 0-9 (except on the starting char)
+	additional_identifier_chars: new Set(['$', '_']),
+
+	// Literals
+	// ----------
+	// Store the values to return for the various literals we may encounter
+	literals: {
+		'true': true,
+		'false': false,
+		'null': null
+	},
+
+	// Except for `this`, which is special. This could be changed to something like `'self'` as well
+	this_str: 'this',
+});
+Jsep.max_unop_len = Jsep.getMaxKeyLen(Jsep.unary_ops);
+Jsep.max_binop_len = Jsep.getMaxKeyLen(Jsep.binary_ops);
+
+module.exports = Jsep;