@duxweb/dvha-core 0.1.20 → 0.1.22

package/dist/esm/node_modules/jsep/dist/jsep.js

@@ -1,737 +0,0 @@
-class x {
-  /**
-   * @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(t, i, n) {
-    if (typeof arguments[0] != "string")
-      for (let r in arguments[0])
-        this.add(r, arguments[0][r], arguments[1]);
-    else
-      (Array.isArray(t) ? t : [t]).forEach(function(r) {
-        this[r] = this[r] || [], i && this[r][n ? "unshift" : "push"](i);
-      }, 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(t, i) {
-    this[t] = this[t] || [], this[t].forEach(function(n) {
-      n.call(i && i.context ? i.context : i, i);
-    });
-  }
-}
-class g {
-  constructor(t) {
-    this.jsep = t, 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(...t) {
-    t.forEach((i) => {
-      if (typeof i != "object" || !i.name || !i.init)
-        throw new Error("Invalid JSEP plugin format");
-      this.registered[i.name] || (i.init(this.jsep), this.registered[i.name] = i);
-    });
-  }
-}
-class e {
-  /**
-   * @returns {string}
-   */
-  static get version() {
-    return "1.4.0";
-  }
-  /**
-   * @returns {string}
-   */
-  static toString() {
-    return "JavaScript Expression Parser (JSEP) v" + e.version;
-  }
-  // ==================== CONFIG ================================
-  /**
-   * @method addUnaryOp
-   * @param {string} op_name The name of the unary op to add
-   * @returns {Jsep}
-   */
-  static addUnaryOp(t) {
-    return e.max_unop_len = Math.max(t.length, e.max_unop_len), e.unary_ops[t] = 1, e;
-  }
-  /**
-   * @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(t, i, n) {
-    return e.max_binop_len = Math.max(t.length, e.max_binop_len), e.binary_ops[t] = i, n ? e.right_associative.add(t) : e.right_associative.delete(t), e;
-  }
-  /**
-   * @method addIdentifierChar
-   * @param {string} char The additional character to treat as a valid part of an identifier
-   * @returns {Jsep}
-   */
-  static addIdentifierChar(t) {
-    return e.additional_identifier_chars.add(t), e;
-  }
-  /**
-   * @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(t, i) {
-    return e.literals[t] = i, e;
-  }
-  /**
-   * @method removeUnaryOp
-   * @param {string} op_name The name of the unary op to remove
-   * @returns {Jsep}
-   */
-  static removeUnaryOp(t) {
-    return delete e.unary_ops[t], t.length === e.max_unop_len && (e.max_unop_len = e.getMaxKeyLen(e.unary_ops)), e;
-  }
-  /**
-   * @method removeAllUnaryOps
-   * @returns {Jsep}
-   */
-  static removeAllUnaryOps() {
-    return e.unary_ops = {}, e.max_unop_len = 0, e;
-  }
-  /**
-   * @method removeIdentifierChar
-   * @param {string} char The additional character to stop treating as a valid part of an identifier
-   * @returns {Jsep}
-   */
-  static removeIdentifierChar(t) {
-    return e.additional_identifier_chars.delete(t), e;
-  }
-  /**
-   * @method removeBinaryOp
-   * @param {string} op_name The name of the binary op to remove
-   * @returns {Jsep}
-   */
-  static removeBinaryOp(t) {
-    return delete e.binary_ops[t], t.length === e.max_binop_len && (e.max_binop_len = e.getMaxKeyLen(e.binary_ops)), e.right_associative.delete(t), e;
-  }
-  /**
-   * @method removeAllBinaryOps
-   * @returns {Jsep}
-   */
-  static removeAllBinaryOps() {
-    return e.binary_ops = {}, e.max_binop_len = 0, e;
-  }
-  /**
-   * @method removeLiteral
-   * @param {string} literal_name The name of the literal to remove
-   * @returns {Jsep}
-   */
-  static removeLiteral(t) {
-    return delete e.literals[t], e;
-  }
-  /**
-   * @method removeAllLiterals
-   * @returns {Jsep}
-   */
-  static removeAllLiterals() {
-    return e.literals = {}, e;
-  }
-  // ==================== 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(t) {
-    this.expr = t, this.index = 0;
-  }
-  /**
-   * static top-level parser
-   * @returns {jsep.Expression}
-   */
-  static parse(t) {
-    return new e(t).parse();
-  }
-  /**
-   * Get the longest key length of any object
-   * @param {object} obj
-   * @returns {number}
-   */
-  static getMaxKeyLen(t) {
-    return Math.max(0, ...Object.keys(t).map((i) => i.length));
-  }
-  /**
-   * `ch` is a character code in the next three functions
-   * @param {number} ch
-   * @returns {boolean}
-   */
-  static isDecimalDigit(t) {
-    return t >= 48 && t <= 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(t) {
-    return e.binary_ops[t] || 0;
-  }
-  /**
-   * Looks for start of identifier
-   * @param {number} ch
-   * @returns {boolean}
-   */
-  static isIdentifierStart(t) {
-    return t >= 65 && t <= 90 || // A...Z
-    t >= 97 && t <= 122 || // a...z
-    t >= 128 && !e.binary_ops[String.fromCharCode(t)] || // any non-ASCII that is not an operator
-    e.additional_identifier_chars.has(String.fromCharCode(t));
-  }
-  /**
-   * @param {number} ch
-   * @returns {boolean}
-   */
-  static isIdentifierPart(t) {
-    return e.isIdentifierStart(t) || e.isDecimalDigit(t);
-  }
-  /**
-   * throw error at index of the expression
-   * @param {string} message
-   * @throws
-   */
-  throwError(t) {
-    const i = new Error(t + " at character " + this.index);
-    throw i.index = this.index, i.description = t, i;
-  }
-  /**
-   * Run a given hook
-   * @param {string} name
-   * @param {jsep.Expression|false} [node]
-   * @returns {?jsep.Expression}
-   */
-  runHook(t, i) {
-    if (e.hooks[t]) {
-      const n = { context: this, node: i };
-      return e.hooks.run(t, n), n.node;
-    }
-    return i;
-  }
-  /**
-   * Runs a given hook until one returns a node
-   * @param {string} name
-   * @returns {?jsep.Expression}
-   */
-  searchHook(t) {
-    if (e.hooks[t]) {
-      const i = { context: this };
-      return e.hooks[t].find(function(n) {
-        return n.call(i.context, i), i.node;
-      }), i.node;
-    }
-  }
-  /**
-   * Push `index` up to the next non-space character
-   */
-  gobbleSpaces() {
-    let t = this.code;
-    for (; t === e.SPACE_CODE || t === e.TAB_CODE || t === e.LF_CODE || t === e.CR_CODE; )
-      t = 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 t = this.gobbleExpressions(), i = t.length === 1 ? t[0] : {
-      type: e.COMPOUND,
-      body: t
-    };
-    return this.runHook("after-all", i);
-  }
-  /**
-   * top-level parser (but can be reused within as well)
-   * @param {number} [untilICode]
-   * @returns {jsep.Expression[]}
-   */
-  gobbleExpressions(t) {
-    let i = [], n, r;
-    for (; this.index < this.expr.length; )
-      if (n = this.code, n === e.SEMCOL_CODE || n === e.COMMA_CODE)
-        this.index++;
-      else if (r = this.gobbleExpression())
-        i.push(r);
-      else if (this.index < this.expr.length) {
-        if (n === t)
-          break;
-        this.throwError('Unexpected "' + this.char + '"');
-      }
-    return i;
-  }
-  /**
-   * The main parsing function.
-   * @returns {?jsep.Expression}
-   */
-  gobbleExpression() {
-    const t = this.searchHook("gobble-expression") || this.gobbleBinaryExpression();
-    return this.gobbleSpaces(), this.runHook("after-expression", t);
-  }
-  /**
-   * 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 t = this.expr.substr(this.index, e.max_binop_len), i = t.length;
-    for (; i > 0; ) {
-      if (e.binary_ops.hasOwnProperty(t) && (!e.isIdentifierStart(this.code) || this.index + t.length < this.expr.length && !e.isIdentifierPart(this.expr.charCodeAt(this.index + t.length))))
-        return this.index += i, t;
-      t = t.substr(0, --i);
-    }
-    return !1;
-  }
-  /**
-   * 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 t, i, n, r, s, o, l, a, E;
-    if (o = this.gobbleToken(), !o || (i = this.gobbleBinaryOp(), !i))
-      return o;
-    for (s = { value: i, prec: e.binaryPrecedence(i), right_a: e.right_associative.has(i) }, l = this.gobbleToken(), l || this.throwError("Expected expression after " + i), r = [o, s, l]; i = this.gobbleBinaryOp(); ) {
-      if (n = e.binaryPrecedence(i), n === 0) {
-        this.index -= i.length;
-        break;
-      }
-      s = { value: i, prec: n, right_a: e.right_associative.has(i) }, E = i;
-      const b = (d) => s.right_a && d.right_a ? n > d.prec : n <= d.prec;
-      for (; r.length > 2 && b(r[r.length - 2]); )
-        l = r.pop(), i = r.pop().value, o = r.pop(), t = {
-          type: e.BINARY_EXP,
-          operator: i,
-          left: o,
-          right: l
-        }, r.push(t);
-      t = this.gobbleToken(), t || this.throwError("Expected expression after " + E), r.push(s, t);
-    }
-    for (a = r.length - 1, t = r[a]; a > 1; )
-      t = {
-        type: e.BINARY_EXP,
-        operator: r[a - 1].value,
-        left: r[a - 2],
-        right: t
-      }, a -= 2;
-    return t;
-  }
-  /**
-   * 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 t, i, n, r;
-    if (this.gobbleSpaces(), r = this.searchHook("gobble-token"), r)
-      return this.runHook("after-token", r);
-    if (t = this.code, e.isDecimalDigit(t) || t === e.PERIOD_CODE)
-      return this.gobbleNumericLiteral();
-    if (t === e.SQUOTE_CODE || t === e.DQUOTE_CODE)
-      r = this.gobbleStringLiteral();
-    else if (t === e.OBRACK_CODE)
-      r = this.gobbleArray();
-    else {
-      for (i = this.expr.substr(this.index, e.max_unop_len), n = i.length; n > 0; ) {
-        if (e.unary_ops.hasOwnProperty(i) && (!e.isIdentifierStart(this.code) || this.index + i.length < this.expr.length && !e.isIdentifierPart(this.expr.charCodeAt(this.index + i.length)))) {
-          this.index += n;
-          const s = this.gobbleToken();
-          return s || this.throwError("missing unaryOp argument"), this.runHook("after-token", {
-            type: e.UNARY_EXP,
-            operator: i,
-            argument: s,
-            prefix: !0
-          });
-        }
-        i = i.substr(0, --n);
-      }
-      e.isIdentifierStart(t) ? (r = this.gobbleIdentifier(), e.literals.hasOwnProperty(r.name) ? r = {
-        type: e.LITERAL,
-        value: e.literals[r.name],
-        raw: r.name
-      } : r.name === e.this_str && (r = { type: e.THIS_EXP })) : t === e.OPAREN_CODE && (r = this.gobbleGroup());
-    }
-    return r ? (r = this.gobbleTokenProperty(r), this.runHook("after-token", r)) : this.runHook("after-token", !1);
-  }
-  /**
-   * 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(t) {
-    this.gobbleSpaces();
-    let i = this.code;
-    for (; i === e.PERIOD_CODE || i === e.OBRACK_CODE || i === e.OPAREN_CODE || i === e.QUMARK_CODE; ) {
-      let n;
-      if (i === e.QUMARK_CODE) {
-        if (this.expr.charCodeAt(this.index + 1) !== e.PERIOD_CODE)
-          break;
-        n = !0, this.index += 2, this.gobbleSpaces(), i = this.code;
-      }
-      this.index++, i === e.OBRACK_CODE ? (t = {
-        type: e.MEMBER_EXP,
-        computed: !0,
-        object: t,
-        property: this.gobbleExpression()
-      }, t.property || this.throwError('Unexpected "' + this.char + '"'), this.gobbleSpaces(), i = this.code, i !== e.CBRACK_CODE && this.throwError("Unclosed ["), this.index++) : i === e.OPAREN_CODE ? t = {
-        type: e.CALL_EXP,
-        arguments: this.gobbleArguments(e.CPAREN_CODE),
-        callee: t
-      } : (i === e.PERIOD_CODE || n) && (n && this.index--, this.gobbleSpaces(), t = {
-        type: e.MEMBER_EXP,
-        computed: !1,
-        object: t,
-        property: this.gobbleIdentifier()
-      }), n && (t.optional = !0), this.gobbleSpaces(), i = this.code;
-    }
-    return t;
-  }
-  /**
-   * 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 t = "", i, n;
-    for (; e.isDecimalDigit(this.code); )
-      t += this.expr.charAt(this.index++);
-    if (this.code === e.PERIOD_CODE)
-      for (t += this.expr.charAt(this.index++); e.isDecimalDigit(this.code); )
-        t += this.expr.charAt(this.index++);
-    if (i = this.char, i === "e" || i === "E") {
-      for (t += this.expr.charAt(this.index++), i = this.char, (i === "+" || i === "-") && (t += this.expr.charAt(this.index++)); e.isDecimalDigit(this.code); )
-        t += this.expr.charAt(this.index++);
-      e.isDecimalDigit(this.expr.charCodeAt(this.index - 1)) || this.throwError("Expected exponent (" + t + this.char + ")");
-    }
-    return n = this.code, e.isIdentifierStart(n) ? this.throwError("Variable names cannot start with a number (" + t + this.char + ")") : (n === e.PERIOD_CODE || t.length === 1 && t.charCodeAt(0) === e.PERIOD_CODE) && this.throwError("Unexpected period"), {
-      type: e.LITERAL,
-      value: parseFloat(t),
-      raw: t
-    };
-  }
-  /**
-   * 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 t = "";
-    const i = this.index, n = this.expr.charAt(this.index++);
-    let r = !1;
-    for (; this.index < this.expr.length; ) {
-      let s = this.expr.charAt(this.index++);
-      if (s === n) {
-        r = !0;
-        break;
-      } else if (s === "\\")
-        switch (s = this.expr.charAt(this.index++), s) {
-          case "n":
-            t += `
-`;
-            break;
-          case "r":
-            t += "\r";
-            break;
-          case "t":
-            t += "	";
-            break;
-          case "b":
-            t += "\b";
-            break;
-          case "f":
-            t += "\f";
-            break;
-          case "v":
-            t += "\v";
-            break;
-          default:
-            t += s;
-        }
-      else
-        t += s;
-    }
-    return r || this.throwError('Unclosed quote after "' + t + '"'), {
-      type: e.LITERAL,
-      value: t,
-      raw: this.expr.substring(i, 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 t = this.code, i = this.index;
-    for (e.isIdentifierStart(t) ? this.index++ : this.throwError("Unexpected " + this.char); this.index < this.expr.length && (t = this.code, e.isIdentifierPart(t)); )
-      this.index++;
-    return {
-      type: e.IDENTIFIER,
-      name: this.expr.slice(i, 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(t) {
-    const i = [];
-    let n = !1, r = 0;
-    for (; this.index < this.expr.length; ) {
-      this.gobbleSpaces();
-      let s = this.code;
-      if (s === t) {
-        n = !0, this.index++, t === e.CPAREN_CODE && r && r >= i.length && this.throwError("Unexpected token " + String.fromCharCode(t));
-        break;
-      } else if (s === e.COMMA_CODE) {
-        if (this.index++, r++, r !== i.length) {
-          if (t === e.CPAREN_CODE)
-            this.throwError("Unexpected token ,");
-          else if (t === e.CBRACK_CODE)
-            for (let o = i.length; o < r; o++)
-              i.push(null);
-        }
-      } else if (i.length !== r && r !== 0)
-        this.throwError("Expected comma");
-      else {
-        const o = this.gobbleExpression();
-        (!o || o.type === e.COMPOUND) && this.throwError("Expected comma"), i.push(o);
-      }
-    }
-    return n || this.throwError("Expected " + String.fromCharCode(t)), i;
-  }
-  /**
-   * 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 t = this.gobbleExpressions(e.CPAREN_CODE);
-    if (this.code === e.CPAREN_CODE)
-      return this.index++, t.length === 1 ? t[0] : t.length ? {
-        type: e.SEQUENCE_EXP,
-        expressions: t
-      } : !1;
-    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() {
-    return this.index++, {
-      type: e.ARRAY_EXP,
-      elements: this.gobbleArguments(e.CBRACK_CODE)
-    };
-  }
-}
-const u = new x();
-Object.assign(e, {
-  hooks: u,
-  plugins: new g(e),
-  // 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: !0,
-    false: !1,
-    null: null
-  },
-  // Except for `this`, which is special. This could be changed to something like `'self'` as well
-  this_str: "this"
-});
-e.max_unop_len = e.getMaxKeyLen(e.unary_ops);
-e.max_binop_len = e.getMaxKeyLen(e.binary_ops);
-const c = (h) => new e(h).parse(), f = Object.getOwnPropertyNames(class {
-});
-Object.getOwnPropertyNames(e).filter((h) => !f.includes(h) && c[h] === void 0).forEach((h) => {
-  c[h] = e[h];
-});
-c.Jsep = e;
-const C = "ConditionalExpression";
-var O = {
-  name: "ternary",
-  init(h) {
-    h.hooks.add("after-expression", function(i) {
-      if (i.node && this.code === h.QUMARK_CODE) {
-        this.index++;
-        const n = i.node, r = this.gobbleExpression();
-        if (r || this.throwError("Expected expression"), this.gobbleSpaces(), this.code === h.COLON_CODE) {
-          this.index++;
-          const s = this.gobbleExpression();
-          if (s || this.throwError("Expected expression"), i.node = {
-            type: C,
-            test: n,
-            consequent: r,
-            alternate: s
-          }, n.operator && h.binary_ops[n.operator] <= 0.9) {
-            let o = n;
-            for (; o.right.operator && h.binary_ops[o.right.operator] <= 0.9; )
-              o = o.right;
-            i.node.test = o.right, o.right = i.node, i.node = n;
-          }
-        } else
-          this.throwError("Expected :");
-      }
-    });
-  }
-};
-c.plugins.register(O);
-export {
-  e as Jsep,
-  c as default
-};