@math.gl/core 5.0.0-alpha.18 → 5.0.0-alpha.19

package/dist/expressions/vendor/jsep/runtime.js

@@ -0,0 +1,972 @@
+// SPDX-License-Identifier: MIT
+// SPDX-FileCopyrightText: Copyright (c) 2013 Stephen Oney
+// @ts-nocheck
+// Generated by scripts/vendor-expression-timezone-deps.mjs; see README.md and LICENSE files.
+// jsep/dist/jsep.js
+var Hooks = class {
+    /**
+     * @callback HookCallback
+     * @this {*|Jsep} this
+     * @param {Jsep} env
+     * @returns: void
+     */
+    /**
+     * Adds the given callback to the list of callbacks for the given hook.
+     *
+     * The callback will be invoked when the hook it is registered for is run.
+     *
+     * One callback function can be registered to multiple hooks and the same hook multiple times.
+     *
+     * @param {string|object} name The name of the hook, or an object of callbacks keyed by name
+     * @param {HookCallback|boolean} callback The callback function which is given environment variables.
+     * @param {?boolean} [first=false] Will add the hook to the top of the list (defaults to the bottom)
+     * @public
+     */
+    add(name, callback, first) {
+        if (typeof arguments[0] != "string") {
+            for (let name2 in arguments[0]) {
+                this.add(name2, arguments[0][name2], arguments[1]);
+            }
+        }
+        else {
+            (Array.isArray(name) ? name : [name]).forEach(function (name2) {
+                this[name2] = this[name2] || [];
+                if (callback) {
+                    this[name2][first ? "unshift" : "push"](callback);
+                }
+            }, this);
+        }
+    }
+    /**
+     * Runs a hook invoking all registered callbacks with the given environment variables.
+     *
+     * Callbacks will be invoked synchronously and in the order in which they were registered.
+     *
+     * @param {string} name The name of the hook.
+     * @param {Object<string, any>} env The environment variables of the hook passed to all callbacks registered.
+     * @public
+     */
+    run(name, env) {
+        this[name] = this[name] || [];
+        this[name].forEach(function (callback) {
+            callback.call(env && env.context ? env.context : env, env);
+        });
+    }
+};
+var Plugins = class {
+    constructor(jsep2) {
+        this.jsep = jsep2;
+        this.registered = {};
+    }
+    /**
+     * @callback PluginSetup
+     * @this {Jsep} jsep
+     * @returns: void
+     */
+    /**
+     * Adds the given plugin(s) to the registry
+     *
+     * @param {object} plugins
+     * @param {string} plugins.name The name of the plugin
+     * @param {PluginSetup} plugins.init The init function
+     * @public
+     */
+    register(...plugins) {
+        plugins.forEach((plugin) => {
+            if (typeof plugin !== "object" || !plugin.name || !plugin.init) {
+                throw new Error("Invalid JSEP plugin format");
+            }
+            if (this.registered[plugin.name]) {
+                return;
+            }
+            plugin.init(this.jsep);
+            this.registered[plugin.name] = plugin;
+        });
+    }
+};
+var Jsep = class _Jsep {
+    /**
+     * @returns {string}
+     */
+    static get version() {
+        return "1.4.0";
+    }
+    /**
+     * @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). Higher number = higher precedence
+     * @param {boolean} [isRightAssociative=false] whether operator is right-associative
+     * @returns {Jsep}
+     */
+    static addBinaryOp(op_name, precedence, isRightAssociative) {
+        _Jsep.max_binop_len = Math.max(op_name.length, _Jsep.max_binop_len);
+        _Jsep.binary_ops[op_name] = precedence;
+        if (isRightAssociative) {
+            _Jsep.right_associative.add(op_name);
+        }
+        else {
+            _Jsep.right_associative.delete(op_name);
+        }
+        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);
+        }
+        _Jsep.right_associative.delete(op_name);
+        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) {
+        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;
+    }
+    /**
+     * 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));
+    }
+    /**
+     * @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;
+    }
+    /**
+     * Run a given hook
+     * @param {string} name
+     * @param {jsep.Expression|false} [node]
+     * @returns {?jsep.Expression}
+     */
+    runHook(name, node) {
+        if (_Jsep.hooks[name]) {
+            const env = { context: this, node };
+            _Jsep.hooks.run(name, env);
+            return env.node;
+        }
+        return node;
+    }
+    /**
+     * Runs a given hook until one returns a node
+     * @param {string} name
+     * @returns {?jsep.Expression}
+     */
+    searchHook(name) {
+        if (_Jsep.hooks[name]) {
+            const env = { context: this };
+            _Jsep.hooks[name].find(function (callback) {
+                callback.call(env.context, env);
+                return env.node;
+            });
+            return env.node;
+        }
+    }
+    /**
+     * Push `index` up to the next non-space character
+     */
+    gobbleSpaces() {
+        let ch = this.code;
+        while (ch === _Jsep.SPACE_CODE || ch === _Jsep.TAB_CODE || ch === _Jsep.LF_CODE || ch === _Jsep.CR_CODE) {
+            ch = this.expr.charCodeAt(++this.index);
+        }
+        this.runHook("gobble-spaces");
+    }
+    /**
+     * Top-level method to parse all expressions and returns compound or single node
+     * @returns {jsep.Expression}
+     */
+    parse() {
+        this.runHook("before-all");
+        const nodes = this.gobbleExpressions();
+        const node = nodes.length === 1 ? nodes[0] : {
+            type: _Jsep.COMPOUND,
+            body: nodes
+        };
+        return this.runHook("after-all", node);
+    }
+    /**
+     * 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;
+            if (ch_i === _Jsep.SEMCOL_CODE || ch_i === _Jsep.COMMA_CODE) {
+                this.index++;
+            }
+            else {
+                if (node = this.gobbleExpression()) {
+                    nodes.push(node);
+                }
+                else if (this.index < this.expr.length) {
+                    if (ch_i === untilICode) {
+                        break;
+                    }
+                    this.throwError('Unexpected "' + this.char + '"');
+                }
+            }
+        }
+        return nodes;
+    }
+    /**
+     * The main parsing function.
+     * @returns {?jsep.Expression}
+     */
+    gobbleExpression() {
+        const node = this.searchHook("gobble-expression") || this.gobbleBinaryExpression();
+        this.gobbleSpaces();
+        return this.runHook("after-expression", node);
+    }
+    /**
+     * 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) {
+            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;
+        left = this.gobbleToken();
+        if (!left) {
+            return left;
+        }
+        biop = this.gobbleBinaryOp();
+        if (!biop) {
+            return left;
+        }
+        biop_info = { value: biop, prec: _Jsep.binaryPrecedence(biop), right_a: _Jsep.right_associative.has(biop) };
+        right = this.gobbleToken();
+        if (!right) {
+            this.throwError("Expected expression after " + biop);
+        }
+        stack = [left, biop_info, right];
+        while (biop = this.gobbleBinaryOp()) {
+            prec = _Jsep.binaryPrecedence(biop);
+            if (prec === 0) {
+                this.index -= biop.length;
+                break;
+            }
+            biop_info = { value: biop, prec, right_a: _Jsep.right_associative.has(biop) };
+            cur_biop = biop;
+            const comparePrev = (prev) => biop_info.right_a && prev.right_a ? prec > prev.prec : prec <= prev.prec;
+            while (stack.length > 2 && comparePrev(stack[stack.length - 2])) {
+                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();
+        node = this.searchHook("gobble-token");
+        if (node) {
+            return this.runHook("after-token", node);
+        }
+        ch = this.code;
+        if (_Jsep.isDecimalDigit(ch) || ch === _Jsep.PERIOD_CODE) {
+            return this.gobbleNumericLiteral();
+        }
+        if (ch === _Jsep.SQUOTE_CODE || ch === _Jsep.DQUOTE_CODE) {
+            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) {
+                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;
+                    const argument = this.gobbleToken();
+                    if (!argument) {
+                        this.throwError("missing unaryOp argument");
+                    }
+                    return this.runHook("after-token", {
+                        type: _Jsep.UNARY_EXP,
+                        operator: to_check,
+                        argument,
+                        prefix: true
+                    });
+                }
+                to_check = to_check.substr(0, --tc_len);
+            }
+            if (_Jsep.isIdentifierStart(ch)) {
+                node = this.gobbleIdentifier();
+                if (_Jsep.literals.hasOwnProperty(node.name)) {
+                    node = {
+                        type: _Jsep.LITERAL,
+                        value: _Jsep.literals[node.name],
+                        raw: node.name
+                    };
+                }
+                else if (node.name === _Jsep.this_str) {
+                    node = { type: _Jsep.THIS_EXP };
+                }
+            }
+            else if (ch === _Jsep.OPAREN_CODE) {
+                node = this.gobbleGroup();
+            }
+        }
+        if (!node) {
+            return this.runHook("after-token", false);
+        }
+        node = this.gobbleTokenProperty(node);
+        return this.runHook("after-token", node);
+    }
+    /**
+     * 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)`
+     * @param {jsep.Expression} node
+     * @returns {jsep.Expression}
+     */
+    gobbleTokenProperty(node) {
+        this.gobbleSpaces();
+        let ch = this.code;
+        while (ch === _Jsep.PERIOD_CODE || ch === _Jsep.OBRACK_CODE || ch === _Jsep.OPAREN_CODE || ch === _Jsep.QUMARK_CODE) {
+            let optional;
+            if (ch === _Jsep.QUMARK_CODE) {
+                if (this.expr.charCodeAt(this.index + 1) !== _Jsep.PERIOD_CODE) {
+                    break;
+                }
+                optional = true;
+                this.index += 2;
+                this.gobbleSpaces();
+                ch = this.code;
+            }
+            this.index++;
+            if (ch === _Jsep.OBRACK_CODE) {
+                node = {
+                    type: _Jsep.MEMBER_EXP,
+                    computed: true,
+                    object: node,
+                    property: this.gobbleExpression()
+                };
+                if (!node.property) {
+                    this.throwError('Unexpected "' + this.char + '"');
+                }
+                this.gobbleSpaces();
+                ch = this.code;
+                if (ch !== _Jsep.CBRACK_CODE) {
+                    this.throwError("Unclosed [");
+                }
+                this.index++;
+            }
+            else if (ch === _Jsep.OPAREN_CODE) {
+                node = {
+                    type: _Jsep.CALL_EXP,
+                    "arguments": this.gobbleArguments(_Jsep.CPAREN_CODE),
+                    callee: node
+                };
+            }
+            else if (ch === _Jsep.PERIOD_CODE || optional) {
+                if (optional) {
+                    this.index--;
+                }
+                this.gobbleSpaces();
+                node = {
+                    type: _Jsep.MEMBER_EXP,
+                    computed: false,
+                    object: node,
+                    property: this.gobbleIdentifier()
+                };
+            }
+            if (optional) {
+                node.optional = true;
+            }
+            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) {
+            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") {
+            number += this.expr.charAt(this.index++);
+            ch = this.char;
+            if (ch === "+" || ch === "-") {
+                number += this.expr.charAt(this.index++);
+            }
+            while (_Jsep.isDecimalDigit(this.code)) {
+                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;
+        if (_Jsep.isIdentifierStart(chCode)) {
+            this.throwError("Variable names cannot start with a number (" + number + this.char + ")");
+        }
+        else if (chCode === _Jsep.PERIOD_CODE || number.length === 1 && number.charCodeAt(0) === _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 = "";
+        const startIndex = this.index;
+        const 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 === "\\") {
+                ch = this.expr.charAt(this.index++);
+                switch (ch) {
+                    case "n":
+                        str += "\n";
+                        break;
+                    case "r":
+                        str += "\r";
+                        break;
+                    case "t":
+                        str += "	";
+                        break;
+                    case "b":
+                        str += "\b";
+                        break;
+                    case "f":
+                        str += "\f";
+                        break;
+                    case "v":
+                        str += "\v";
+                        break;
+                    default:
+                        str += ch;
+                }
+            }
+            else {
+                str += ch;
+            }
+        }
+        if (!closed) {
+            this.throwError('Unclosed quote after "' + str + '"');
+        }
+        return {
+            type: _Jsep.LITERAL,
+            value: str,
+            raw: this.expr.substring(startIndex, this.index)
+        };
+    }
+    /**
+     * 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.Identifier}
+     */
+    gobbleIdentifier() {
+        let ch = this.code, start = this.index;
+        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;
+            }
+        }
+        return {
+            type: _Jsep.IDENTIFIER,
+            name: this.expr.slice(start, this.index)
+        };
+    }
+    /**
+     * 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 {number} 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) {
+                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) {
+                this.index++;
+                separator_count++;
+                if (separator_count !== args.length) {
+                    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 if (args.length !== separator_count && separator_count !== 0) {
+                this.throwError("Expected comma");
+            }
+            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)
+        };
+    }
+};
+var hooks = new Hooks();
+Object.assign(Jsep, {
+    hooks,
+    plugins: new Plugins(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",
+    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 (higher number = higher precedence)
+    // see [Order of operations](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Operators/Operator_Precedence)
+    binary_ops: {
+        "||": 1,
+        "??": 1,
+        "&&": 2,
+        "|": 3,
+        "^": 4,
+        "&": 5,
+        "==": 6,
+        "!=": 6,
+        "===": 6,
+        "!==": 6,
+        "<": 7,
+        ">": 7,
+        "<=": 7,
+        ">=": 7,
+        "<<": 8,
+        ">>": 8,
+        ">>>": 8,
+        "+": 9,
+        "-": 9,
+        "*": 10,
+        "/": 10,
+        "%": 10,
+        "**": 11
+    },
+    // sets specific binary_ops as right-associative
+    right_associative: /* @__PURE__ */ new Set(["**"]),
+    // Additional valid identifier chars, apart from a-z, A-Z and 0-9 (except on the starting char)
+    additional_identifier_chars: /* @__PURE__ */ 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);
+var jsep = (expr) => new Jsep(expr).parse();
+var stdClassProps = Object.getOwnPropertyNames(class Test {
+});
+Object.getOwnPropertyNames(Jsep).filter((prop) => !stdClassProps.includes(prop) && jsep[prop] === void 0).forEach((m) => {
+    jsep[m] = Jsep[m];
+});
+jsep.Jsep = Jsep;
+var CONDITIONAL_EXP = "ConditionalExpression";
+var ternary = {
+    name: "ternary",
+    init(jsep2) {
+        jsep2.hooks.add("after-expression", function gobbleTernary(env) {
+            if (env.node && this.code === jsep2.QUMARK_CODE) {
+                this.index++;
+                const test = env.node;
+                const consequent = this.gobbleExpression();
+                if (!consequent) {
+                    this.throwError("Expected expression");
+                }
+                this.gobbleSpaces();
+                if (this.code === jsep2.COLON_CODE) {
+                    this.index++;
+                    const alternate = this.gobbleExpression();
+                    if (!alternate) {
+                        this.throwError("Expected expression");
+                    }
+                    env.node = {
+                        type: CONDITIONAL_EXP,
+                        test,
+                        consequent,
+                        alternate
+                    };
+                    if (test.operator && jsep2.binary_ops[test.operator] <= 0.9) {
+                        let newTest = test;
+                        while (newTest.right.operator && jsep2.binary_ops[newTest.right.operator] <= 0.9) {
+                            newTest = newTest.right;
+                        }
+                        env.node.test = newTest.right;
+                        newTest.right = env.node;
+                        env.node = test;
+                    }
+                }
+                else {
+                    this.throwError("Expected :");
+                }
+            }
+        });
+    }
+};
+jsep.plugins.register(ternary);
+export default jsep;
+//# sourceMappingURL=runtime.js.map