@duxweb/dvha-naiveui 1.0.11 → 1.0.12

package/dist/esm/node_modules/.pnpm/jsep@1.4.0/node_modules/jsep/dist/jsep.js

@@ -0,0 +1,737 @@
+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
+};