lone-format 0.1.3 → 0.1.4

package/dist/lone-format.js

@@ -1,32 +1,1333 @@
-import { defineComponent as z, useCssVars as Q, ref as C, computed as g, resolveComponent as X, createElementBlock as a, openBlock as u, createElementVNode as _, createCommentVNode as k, withDirectives as R, toDisplayString as $, withKeys as O, vModelText as q, createTextVNode as Y, Fragment as Z, renderList as ee, createVNode as W, normalizeClass as te, nextTick as K, watch as ne } from "vue";
-const se = { class: "json-node" }, oe = {
+import { defineComponent as ae, useCssVars as ue, ref as B, computed as j, resolveComponent as he, createElementBlock as w, openBlock as k, createElementVNode as P, createCommentVNode as N, withDirectives as te, toDisplayString as U, withKeys as X, vModelText as re, createTextVNode as ie, Fragment as de, renderList as fe, createVNode as le, normalizeClass as pe, nextTick as ee, watch as ye } from "vue";
+class ge {
+  /**
+   * @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(e, t, s) {
+    if (typeof arguments[0] != "string")
+      for (let n in arguments[0])
+        this.add(n, arguments[0][n], arguments[1]);
+    else
+      (Array.isArray(e) ? e : [e]).forEach(function(n) {
+        this[n] = this[n] || [], t && this[n][s ? "unshift" : "push"](t);
+      }, 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(e, t) {
+    this[e] = this[e] || [], this[e].forEach(function(s) {
+      s.call(t && t.context ? t.context : t, t);
+    });
+  }
+}
+class Ee {
+  constructor(e) {
+    this.jsep = e, 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() {
+    for (var e = arguments.length, t = new Array(e), s = 0; s < e; s++)
+      t[s] = arguments[s];
+    t.forEach((n) => {
+      if (typeof n != "object" || !n.name || !n.init)
+        throw new Error("Invalid JSEP plugin format");
+      this.registered[n.name] || (n.init(this.jsep), this.registered[n.name] = n);
+    });
+  }
+}
+class i {
+  /**
+   * @returns {string}
+   */
+  static get version() {
+    return "1.4.0";
+  }
+  /**
+   * @returns {string}
+   */
+  static toString() {
+    return "JavaScript Expression Parser (JSEP) v" + i.version;
+  }
+  // ==================== CONFIG ================================
+  /**
+   * @method addUnaryOp
+   * @param {string} op_name The name of the unary op to add
+   * @returns {Jsep}
+   */
+  static addUnaryOp(e) {
+    return i.max_unop_len = Math.max(e.length, i.max_unop_len), i.unary_ops[e] = 1, i;
+  }
+  /**
+   * @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(e, t, s) {
+    return i.max_binop_len = Math.max(e.length, i.max_binop_len), i.binary_ops[e] = t, s ? i.right_associative.add(e) : i.right_associative.delete(e), i;
+  }
+  /**
+   * @method addIdentifierChar
+   * @param {string} char The additional character to treat as a valid part of an identifier
+   * @returns {Jsep}
+   */
+  static addIdentifierChar(e) {
+    return i.additional_identifier_chars.add(e), i;
+  }
+  /**
+   * @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(e, t) {
+    return i.literals[e] = t, i;
+  }
+  /**
+   * @method removeUnaryOp
+   * @param {string} op_name The name of the unary op to remove
+   * @returns {Jsep}
+   */
+  static removeUnaryOp(e) {
+    return delete i.unary_ops[e], e.length === i.max_unop_len && (i.max_unop_len = i.getMaxKeyLen(i.unary_ops)), i;
+  }
+  /**
+   * @method removeAllUnaryOps
+   * @returns {Jsep}
+   */
+  static removeAllUnaryOps() {
+    return i.unary_ops = {}, i.max_unop_len = 0, i;
+  }
+  /**
+   * @method removeIdentifierChar
+   * @param {string} char The additional character to stop treating as a valid part of an identifier
+   * @returns {Jsep}
+   */
+  static removeIdentifierChar(e) {
+    return i.additional_identifier_chars.delete(e), i;
+  }
+  /**
+   * @method removeBinaryOp
+   * @param {string} op_name The name of the binary op to remove
+   * @returns {Jsep}
+   */
+  static removeBinaryOp(e) {
+    return delete i.binary_ops[e], e.length === i.max_binop_len && (i.max_binop_len = i.getMaxKeyLen(i.binary_ops)), i.right_associative.delete(e), i;
+  }
+  /**
+   * @method removeAllBinaryOps
+   * @returns {Jsep}
+   */
+  static removeAllBinaryOps() {
+    return i.binary_ops = {}, i.max_binop_len = 0, i;
+  }
+  /**
+   * @method removeLiteral
+   * @param {string} literal_name The name of the literal to remove
+   * @returns {Jsep}
+   */
+  static removeLiteral(e) {
+    return delete i.literals[e], i;
+  }
+  /**
+   * @method removeAllLiterals
+   * @returns {Jsep}
+   */
+  static removeAllLiterals() {
+    return i.literals = {}, i;
+  }
+  // ==================== 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(e) {
+    this.expr = e, this.index = 0;
+  }
+  /**
+   * static top-level parser
+   * @returns {jsep.Expression}
+   */
+  static parse(e) {
+    return new i(e).parse();
+  }
+  /**
+   * Get the longest key length of any object
+   * @param {object} obj
+   * @returns {number}
+   */
+  static getMaxKeyLen(e) {
+    return Math.max(0, ...Object.keys(e).map((t) => t.length));
+  }
+  /**
+   * `ch` is a character code in the next three functions
+   * @param {number} ch
+   * @returns {boolean}
+   */
+  static isDecimalDigit(e) {
+    return e >= 48 && e <= 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(e) {
+    return i.binary_ops[e] || 0;
+  }
+  /**
+   * Looks for start of identifier
+   * @param {number} ch
+   * @returns {boolean}
+   */
+  static isIdentifierStart(e) {
+    return e >= 65 && e <= 90 || // A...Z
+    e >= 97 && e <= 122 || // a...z
+    e >= 128 && !i.binary_ops[String.fromCharCode(e)] || // any non-ASCII that is not an operator
+    i.additional_identifier_chars.has(String.fromCharCode(e));
+  }
+  /**
+   * @param {number} ch
+   * @returns {boolean}
+   */
+  static isIdentifierPart(e) {
+    return i.isIdentifierStart(e) || i.isDecimalDigit(e);
+  }
+  /**
+   * throw error at index of the expression
+   * @param {string} message
+   * @throws
+   */
+  throwError(e) {
+    const t = new Error(e + " at character " + this.index);
+    throw t.index = this.index, t.description = e, t;
+  }
+  /**
+   * Run a given hook
+   * @param {string} name
+   * @param {jsep.Expression|false} [node]
+   * @returns {?jsep.Expression}
+   */
+  runHook(e, t) {
+    if (i.hooks[e]) {
+      const s = {
+        context: this,
+        node: t
+      };
+      return i.hooks.run(e, s), s.node;
+    }
+    return t;
+  }
+  /**
+   * Runs a given hook until one returns a node
+   * @param {string} name
+   * @returns {?jsep.Expression}
+   */
+  searchHook(e) {
+    if (i.hooks[e]) {
+      const t = {
+        context: this
+      };
+      return i.hooks[e].find(function(s) {
+        return s.call(t.context, t), t.node;
+      }), t.node;
+    }
+  }
+  /**
+   * Push `index` up to the next non-space character
+   */
+  gobbleSpaces() {
+    let e = this.code;
+    for (; e === i.SPACE_CODE || e === i.TAB_CODE || e === i.LF_CODE || e === i.CR_CODE; )
+      e = 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 e = this.gobbleExpressions(), t = e.length === 1 ? e[0] : {
+      type: i.COMPOUND,
+      body: e
+    };
+    return this.runHook("after-all", t);
+  }
+  /**
+   * top-level parser (but can be reused within as well)
+   * @param {number} [untilICode]
+   * @returns {jsep.Expression[]}
+   */
+  gobbleExpressions(e) {
+    let t = [], s, n;
+    for (; this.index < this.expr.length; )
+      if (s = this.code, s === i.SEMCOL_CODE || s === i.COMMA_CODE)
+        this.index++;
+      else if (n = this.gobbleExpression())
+        t.push(n);
+      else if (this.index < this.expr.length) {
+        if (s === e)
+          break;
+        this.throwError('Unexpected "' + this.char + '"');
+      }
+    return t;
+  }
+  /**
+   * The main parsing function.
+   * @returns {?jsep.Expression}
+   */
+  gobbleExpression() {
+    const e = this.searchHook("gobble-expression") || this.gobbleBinaryExpression();
+    return this.gobbleSpaces(), this.runHook("after-expression", e);
+  }
+  /**
+   * 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 e = this.expr.substr(this.index, i.max_binop_len), t = e.length;
+    for (; t > 0; ) {
+      if (i.binary_ops.hasOwnProperty(e) && (!i.isIdentifierStart(this.code) || this.index + e.length < this.expr.length && !i.isIdentifierPart(this.expr.charCodeAt(this.index + e.length))))
+        return this.index += t, e;
+      e = e.substr(0, --t);
+    }
+    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 e, t, s, n, a, c, d, u, h;
+    if (c = this.gobbleToken(), !c || (t = this.gobbleBinaryOp(), !t))
+      return c;
+    for (a = {
+      value: t,
+      prec: i.binaryPrecedence(t),
+      right_a: i.right_associative.has(t)
+    }, d = this.gobbleToken(), d || this.throwError("Expected expression after " + t), n = [c, a, d]; t = this.gobbleBinaryOp(); ) {
+      if (s = i.binaryPrecedence(t), s === 0) {
+        this.index -= t.length;
+        break;
+      }
+      a = {
+        value: t,
+        prec: s,
+        right_a: i.right_associative.has(t)
+      }, h = t;
+      const b = (m) => a.right_a && m.right_a ? s > m.prec : s <= m.prec;
+      for (; n.length > 2 && b(n[n.length - 2]); )
+        d = n.pop(), t = n.pop().value, c = n.pop(), e = {
+          type: i.BINARY_EXP,
+          operator: t,
+          left: c,
+          right: d
+        }, n.push(e);
+      e = this.gobbleToken(), e || this.throwError("Expected expression after " + h), n.push(a, e);
+    }
+    for (u = n.length - 1, e = n[u]; u > 1; )
+      e = {
+        type: i.BINARY_EXP,
+        operator: n[u - 1].value,
+        left: n[u - 2],
+        right: e
+      }, u -= 2;
+    return e;
+  }
+  /**
+   * 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 e, t, s, n;
+    if (this.gobbleSpaces(), n = this.searchHook("gobble-token"), n)
+      return this.runHook("after-token", n);
+    if (e = this.code, i.isDecimalDigit(e) || e === i.PERIOD_CODE)
+      return this.gobbleNumericLiteral();
+    if (e === i.SQUOTE_CODE || e === i.DQUOTE_CODE)
+      n = this.gobbleStringLiteral();
+    else if (e === i.OBRACK_CODE)
+      n = this.gobbleArray();
+    else {
+      for (t = this.expr.substr(this.index, i.max_unop_len), s = t.length; s > 0; ) {
+        if (i.unary_ops.hasOwnProperty(t) && (!i.isIdentifierStart(this.code) || this.index + t.length < this.expr.length && !i.isIdentifierPart(this.expr.charCodeAt(this.index + t.length)))) {
+          this.index += s;
+          const a = this.gobbleToken();
+          return a || this.throwError("missing unaryOp argument"), this.runHook("after-token", {
+            type: i.UNARY_EXP,
+            operator: t,
+            argument: a,
+            prefix: !0
+          });
+        }
+        t = t.substr(0, --s);
+      }
+      i.isIdentifierStart(e) ? (n = this.gobbleIdentifier(), i.literals.hasOwnProperty(n.name) ? n = {
+        type: i.LITERAL,
+        value: i.literals[n.name],
+        raw: n.name
+      } : n.name === i.this_str && (n = {
+        type: i.THIS_EXP
+      })) : e === i.OPAREN_CODE && (n = this.gobbleGroup());
+    }
+    return n ? (n = this.gobbleTokenProperty(n), this.runHook("after-token", n)) : 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(e) {
+    this.gobbleSpaces();
+    let t = this.code;
+    for (; t === i.PERIOD_CODE || t === i.OBRACK_CODE || t === i.OPAREN_CODE || t === i.QUMARK_CODE; ) {
+      let s;
+      if (t === i.QUMARK_CODE) {
+        if (this.expr.charCodeAt(this.index + 1) !== i.PERIOD_CODE)
+          break;
+        s = !0, this.index += 2, this.gobbleSpaces(), t = this.code;
+      }
+      this.index++, t === i.OBRACK_CODE ? (e = {
+        type: i.MEMBER_EXP,
+        computed: !0,
+        object: e,
+        property: this.gobbleExpression()
+      }, e.property || this.throwError('Unexpected "' + this.char + '"'), this.gobbleSpaces(), t = this.code, t !== i.CBRACK_CODE && this.throwError("Unclosed ["), this.index++) : t === i.OPAREN_CODE ? e = {
+        type: i.CALL_EXP,
+        arguments: this.gobbleArguments(i.CPAREN_CODE),
+        callee: e
+      } : (t === i.PERIOD_CODE || s) && (s && this.index--, this.gobbleSpaces(), e = {
+        type: i.MEMBER_EXP,
+        computed: !1,
+        object: e,
+        property: this.gobbleIdentifier()
+      }), s && (e.optional = !0), this.gobbleSpaces(), t = this.code;
+    }
+    return e;
+  }
+  /**
+   * 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 e = "", t, s;
+    for (; i.isDecimalDigit(this.code); )
+      e += this.expr.charAt(this.index++);
+    if (this.code === i.PERIOD_CODE)
+      for (e += this.expr.charAt(this.index++); i.isDecimalDigit(this.code); )
+        e += this.expr.charAt(this.index++);
+    if (t = this.char, t === "e" || t === "E") {
+      for (e += this.expr.charAt(this.index++), t = this.char, (t === "+" || t === "-") && (e += this.expr.charAt(this.index++)); i.isDecimalDigit(this.code); )
+        e += this.expr.charAt(this.index++);
+      i.isDecimalDigit(this.expr.charCodeAt(this.index - 1)) || this.throwError("Expected exponent (" + e + this.char + ")");
+    }
+    return s = this.code, i.isIdentifierStart(s) ? this.throwError("Variable names cannot start with a number (" + e + this.char + ")") : (s === i.PERIOD_CODE || e.length === 1 && e.charCodeAt(0) === i.PERIOD_CODE) && this.throwError("Unexpected period"), {
+      type: i.LITERAL,
+      value: parseFloat(e),
+      raw: e
+    };
+  }
+  /**
+   * 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 e = "";
+    const t = this.index, s = this.expr.charAt(this.index++);
+    let n = !1;
+    for (; this.index < this.expr.length; ) {
+      let a = this.expr.charAt(this.index++);
+      if (a === s) {
+        n = !0;
+        break;
+      } else if (a === "\\")
+        switch (a = this.expr.charAt(this.index++), a) {
+          case "n":
+            e += `
+`;
+            break;
+          case "r":
+            e += "\r";
+            break;
+          case "t":
+            e += "	";
+            break;
+          case "b":
+            e += "\b";
+            break;
+          case "f":
+            e += "\f";
+            break;
+          case "v":
+            e += "\v";
+            break;
+          default:
+            e += a;
+        }
+      else
+        e += a;
+    }
+    return n || this.throwError('Unclosed quote after "' + e + '"'), {
+      type: i.LITERAL,
+      value: e,
+      raw: this.expr.substring(t, 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 e = this.code, t = this.index;
+    for (i.isIdentifierStart(e) ? this.index++ : this.throwError("Unexpected " + this.char); this.index < this.expr.length && (e = this.code, i.isIdentifierPart(e)); )
+      this.index++;
+    return {
+      type: i.IDENTIFIER,
+      name: this.expr.slice(t, 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(e) {
+    const t = [];
+    let s = !1, n = 0;
+    for (; this.index < this.expr.length; ) {
+      this.gobbleSpaces();
+      let a = this.code;
+      if (a === e) {
+        s = !0, this.index++, e === i.CPAREN_CODE && n && n >= t.length && this.throwError("Unexpected token " + String.fromCharCode(e));
+        break;
+      } else if (a === i.COMMA_CODE) {
+        if (this.index++, n++, n !== t.length) {
+          if (e === i.CPAREN_CODE)
+            this.throwError("Unexpected token ,");
+          else if (e === i.CBRACK_CODE)
+            for (let c = t.length; c < n; c++)
+              t.push(null);
+        }
+      } else if (t.length !== n && n !== 0)
+        this.throwError("Expected comma");
+      else {
+        const c = this.gobbleExpression();
+        (!c || c.type === i.COMPOUND) && this.throwError("Expected comma"), t.push(c);
+      }
+    }
+    return s || this.throwError("Expected " + String.fromCharCode(e)), t;
+  }
+  /**
+   * 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 e = this.gobbleExpressions(i.CPAREN_CODE);
+    if (this.code === i.CPAREN_CODE)
+      return this.index++, e.length === 1 ? e[0] : e.length ? {
+        type: i.SEQUENCE_EXP,
+        expressions: e
+      } : !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: i.ARRAY_EXP,
+      elements: this.gobbleArguments(i.CBRACK_CODE)
+    };
+  }
+}
+const be = new ge();
+Object.assign(i, {
+  hooks: be,
+  plugins: new Ee(i),
+  // 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"
+});
+i.max_unop_len = i.getMaxKeyLen(i.unary_ops);
+i.max_binop_len = i.getMaxKeyLen(i.binary_ops);
+const L = (r) => new i(r).parse(), ve = Object.getOwnPropertyNames(class {
+});
+Object.getOwnPropertyNames(i).filter((r) => !ve.includes(r) && L[r] === void 0).forEach((r) => {
+  L[r] = i[r];
+});
+L.Jsep = i;
+const _e = "ConditionalExpression";
+var me = {
+  name: "ternary",
+  init(r) {
+    r.hooks.add("after-expression", function(t) {
+      if (t.node && this.code === r.QUMARK_CODE) {
+        this.index++;
+        const s = t.node, n = this.gobbleExpression();
+        if (n || this.throwError("Expected expression"), this.gobbleSpaces(), this.code === r.COLON_CODE) {
+          this.index++;
+          const a = this.gobbleExpression();
+          if (a || this.throwError("Expected expression"), t.node = {
+            type: _e,
+            test: s,
+            consequent: n,
+            alternate: a
+          }, s.operator && r.binary_ops[s.operator] <= 0.9) {
+            let c = s;
+            for (; c.right.operator && r.binary_ops[c.right.operator] <= 0.9; )
+              c = c.right;
+            t.node.test = c.right, c.right = t.node, t.node = s;
+          }
+        } else
+          this.throwError("Expected :");
+      }
+    });
+  }
+};
+L.plugins.register(me);
+const oe = 47, xe = 92;
+var Oe = {
+  name: "regex",
+  init(r) {
+    r.hooks.add("gobble-token", function(t) {
+      if (this.code === oe) {
+        const s = ++this.index;
+        let n = !1;
+        for (; this.index < this.expr.length; ) {
+          if (this.code === oe && !n) {
+            const a = this.expr.slice(s, this.index);
+            let c = "";
+            for (; ++this.index < this.expr.length; ) {
+              const u = this.code;
+              if (u >= 97 && u <= 122 || u >= 65 && u <= 90 || u >= 48 && u <= 57)
+                c += this.char;
+              else
+                break;
+            }
+            let d;
+            try {
+              d = new RegExp(a, c);
+            } catch (u) {
+              this.throwError(u.message);
+            }
+            return t.node = {
+              type: r.LITERAL,
+              value: d,
+              raw: this.expr.slice(s - 1, this.index)
+            }, t.node = this.gobbleTokenProperty(t.node), t.node;
+          }
+          this.code === r.OBRACK_CODE ? n = !0 : n && this.code === r.CBRACK_CODE && (n = !1), this.index += this.code === xe ? 2 : 1;
+        }
+        this.throwError("Unclosed Regex");
+      }
+    });
+  }
+};
+const ne = 43, Ce = 45, H = {
+  name: "assignment",
+  assignmentOperators: /* @__PURE__ */ new Set(["=", "*=", "**=", "/=", "%=", "+=", "-=", "<<=", ">>=", ">>>=", "&=", "^=", "|=", "||=", "&&=", "??="]),
+  updateOperators: [ne, Ce],
+  assignmentPrecedence: 0.9,
+  init(r) {
+    const e = [r.IDENTIFIER, r.MEMBER_EXP];
+    H.assignmentOperators.forEach((s) => r.addBinaryOp(s, H.assignmentPrecedence, !0)), r.hooks.add("gobble-token", function(n) {
+      const a = this.code;
+      H.updateOperators.some((c) => c === a && c === this.expr.charCodeAt(this.index + 1)) && (this.index += 2, n.node = {
+        type: "UpdateExpression",
+        operator: a === ne ? "++" : "--",
+        argument: this.gobbleTokenProperty(this.gobbleIdentifier()),
+        prefix: !0
+      }, (!n.node.argument || !e.includes(n.node.argument.type)) && this.throwError(`Unexpected ${n.node.operator}`));
+    }), r.hooks.add("after-token", function(n) {
+      if (n.node) {
+        const a = this.code;
+        H.updateOperators.some((c) => c === a && c === this.expr.charCodeAt(this.index + 1)) && (e.includes(n.node.type) || this.throwError(`Unexpected ${n.node.operator}`), this.index += 2, n.node = {
+          type: "UpdateExpression",
+          operator: a === ne ? "++" : "--",
+          argument: n.node,
+          prefix: !1
+        });
+      }
+    }), r.hooks.add("after-expression", function(n) {
+      n.node && t(n.node);
+    });
+    function t(s) {
+      H.assignmentOperators.has(s.operator) ? (s.type = "AssignmentExpression", t(s.left), t(s.right)) : s.operator || Object.values(s).forEach((n) => {
+        n && typeof n == "object" && t(n);
+      });
+    }
+  }
+};
+L.plugins.register(Oe, H);
+L.addUnaryOp("typeof");
+L.addLiteral("null", null);
+L.addLiteral("undefined", void 0);
+const Ae = /* @__PURE__ */ new Set(["constructor", "__proto__", "__defineGetter__", "__defineSetter__"]), O = {
+  /**
+   * @param {jsep.Expression} ast
+   * @param {Record<string, any>} subs
+   */
+  evalAst(r, e) {
+    switch (r.type) {
+      case "BinaryExpression":
+      case "LogicalExpression":
+        return O.evalBinaryExpression(r, e);
+      case "Compound":
+        return O.evalCompound(r, e);
+      case "ConditionalExpression":
+        return O.evalConditionalExpression(r, e);
+      case "Identifier":
+        return O.evalIdentifier(r, e);
+      case "Literal":
+        return O.evalLiteral(r, e);
+      case "MemberExpression":
+        return O.evalMemberExpression(r, e);
+      case "UnaryExpression":
+        return O.evalUnaryExpression(r, e);
+      case "ArrayExpression":
+        return O.evalArrayExpression(r, e);
+      case "CallExpression":
+        return O.evalCallExpression(r, e);
+      case "AssignmentExpression":
+        return O.evalAssignmentExpression(r, e);
+      default:
+        throw SyntaxError("Unexpected expression", r);
+    }
+  },
+  evalBinaryExpression(r, e) {
+    return {
+      "||": (s, n) => s || n(),
+      "&&": (s, n) => s && n(),
+      "|": (s, n) => s | n(),
+      "^": (s, n) => s ^ n(),
+      "&": (s, n) => s & n(),
+      // eslint-disable-next-line eqeqeq -- API
+      "==": (s, n) => s == n(),
+      // eslint-disable-next-line eqeqeq -- API
+      "!=": (s, n) => s != n(),
+      "===": (s, n) => s === n(),
+      "!==": (s, n) => s !== n(),
+      "<": (s, n) => s < n(),
+      ">": (s, n) => s > n(),
+      "<=": (s, n) => s <= n(),
+      ">=": (s, n) => s >= n(),
+      "<<": (s, n) => s << n(),
+      ">>": (s, n) => s >> n(),
+      ">>>": (s, n) => s >>> n(),
+      "+": (s, n) => s + n(),
+      "-": (s, n) => s - n(),
+      "*": (s, n) => s * n(),
+      "/": (s, n) => s / n(),
+      "%": (s, n) => s % n()
+    }[r.operator](O.evalAst(r.left, e), () => O.evalAst(r.right, e));
+  },
+  evalCompound(r, e) {
+    let t;
+    for (let s = 0; s < r.body.length; s++) {
+      r.body[s].type === "Identifier" && ["var", "let", "const"].includes(r.body[s].name) && r.body[s + 1] && r.body[s + 1].type === "AssignmentExpression" && (s += 1);
+      const n = r.body[s];
+      t = O.evalAst(n, e);
+    }
+    return t;
+  },
+  evalConditionalExpression(r, e) {
+    return O.evalAst(r.test, e) ? O.evalAst(r.consequent, e) : O.evalAst(r.alternate, e);
+  },
+  evalIdentifier(r, e) {
+    if (Object.hasOwn(e, r.name))
+      return e[r.name];
+    throw ReferenceError(`${r.name} is not defined`);
+  },
+  evalLiteral(r) {
+    return r.value;
+  },
+  evalMemberExpression(r, e) {
+    const t = String(
+      // NOTE: `String(value)` throws error when
+      // value has overwritten the toString method to return non-string
+      // i.e. `value = {toString: () => []}`
+      r.computed ? O.evalAst(r.property) : r.property.name
+      // `object.property` property is Identifier
+    ), s = O.evalAst(r.object, e);
+    if (s == null)
+      throw TypeError(`Cannot read properties of ${s} (reading '${t}')`);
+    if (!Object.hasOwn(s, t) && Ae.has(t))
+      throw TypeError(`Cannot read properties of ${s} (reading '${t}')`);
+    const n = s[t];
+    return typeof n == "function" ? n.bind(s) : n;
+  },
+  evalUnaryExpression(r, e) {
+    return {
+      "-": (s) => -O.evalAst(s, e),
+      "!": (s) => !O.evalAst(s, e),
+      "~": (s) => ~O.evalAst(s, e),
+      // eslint-disable-next-line no-implicit-coercion -- API
+      "+": (s) => +O.evalAst(s, e),
+      typeof: (s) => typeof O.evalAst(s, e)
+    }[r.operator](r.argument);
+  },
+  evalArrayExpression(r, e) {
+    return r.elements.map((t) => O.evalAst(t, e));
+  },
+  evalCallExpression(r, e) {
+    const t = r.arguments.map((n) => O.evalAst(n, e));
+    return O.evalAst(r.callee, e)(...t);
+  },
+  evalAssignmentExpression(r, e) {
+    if (r.left.type !== "Identifier")
+      throw SyntaxError("Invalid left-hand side in assignment");
+    const t = r.left.name, s = O.evalAst(r.right, e);
+    return e[t] = s, e[t];
+  }
+};
+class we {
+  /**
+   * @param {string} expr Expression to evaluate
+   */
+  constructor(e) {
+    this.code = e, this.ast = L(this.code);
+  }
+  /**
+   * @param {object} context Object whose items will be added
+   *   to evaluation
+   * @returns {EvaluatedResult} Result of evaluated code
+   */
+  runInNewContext(e) {
+    const t = Object.assign(/* @__PURE__ */ Object.create(null), e);
+    return O.evalAst(this.ast, t);
+  }
+}
+function F(r, e) {
+  return r = r.slice(), r.push(e), r;
+}
+function se(r, e) {
+  return e = e.slice(), e.unshift(r), e;
+}
+class ke extends Error {
+  /**
+   * @param {AnyResult} value The evaluated scalar value
+   */
+  constructor(e) {
+    super('JSONPath should not be called with "new" (it prevents return of (unwrapped) scalar values)'), this.avoidNew = !0, this.value = e, this.name = "NewError";
+  }
+}
+function x(r, e, t, s, n) {
+  if (!(this instanceof x))
+    try {
+      return new x(r, e, t, s, n);
+    } catch (c) {
+      if (!c.avoidNew)
+        throw c;
+      return c.value;
+    }
+  typeof r == "string" && (n = s, s = t, t = e, e = r, r = null);
+  const a = r && typeof r == "object";
+  if (r = r || {}, this.json = r.json || t, this.path = r.path || e, this.resultType = r.resultType || "value", this.flatten = r.flatten || !1, this.wrap = Object.hasOwn(r, "wrap") ? r.wrap : !0, this.sandbox = r.sandbox || {}, this.eval = r.eval === void 0 ? "safe" : r.eval, this.ignoreEvalErrors = typeof r.ignoreEvalErrors > "u" ? !1 : r.ignoreEvalErrors, this.parent = r.parent || null, this.parentProperty = r.parentProperty || null, this.callback = r.callback || s || null, this.otherTypeCallback = r.otherTypeCallback || n || function() {
+    throw new TypeError("You must supply an otherTypeCallback callback option with the @other() operator.");
+  }, r.autostart !== !1) {
+    const c = {
+      path: a ? r.path : e
+    };
+    a ? "json" in r && (c.json = r.json) : c.json = t;
+    const d = this.evaluate(c);
+    if (!d || typeof d != "object")
+      throw new ke(d);
+    return d;
+  }
+}
+x.prototype.evaluate = function(r, e, t, s) {
+  let n = this.parent, a = this.parentProperty, {
+    flatten: c,
+    wrap: d
+  } = this;
+  if (this.currResultType = this.resultType, this.currEval = this.eval, this.currSandbox = this.sandbox, t = t || this.callback, this.currOtherTypeCallback = s || this.otherTypeCallback, e = e || this.json, r = r || this.path, r && typeof r == "object" && !Array.isArray(r)) {
+    if (!r.path && r.path !== "")
+      throw new TypeError('You must supply a "path" property when providing an object argument to JSONPath.evaluate().');
+    if (!Object.hasOwn(r, "json"))
+      throw new TypeError('You must supply a "json" property when providing an object argument to JSONPath.evaluate().');
+    ({
+      json: e
+    } = r), c = Object.hasOwn(r, "flatten") ? r.flatten : c, this.currResultType = Object.hasOwn(r, "resultType") ? r.resultType : this.currResultType, this.currSandbox = Object.hasOwn(r, "sandbox") ? r.sandbox : this.currSandbox, d = Object.hasOwn(r, "wrap") ? r.wrap : d, this.currEval = Object.hasOwn(r, "eval") ? r.eval : this.currEval, t = Object.hasOwn(r, "callback") ? r.callback : t, this.currOtherTypeCallback = Object.hasOwn(r, "otherTypeCallback") ? r.otherTypeCallback : this.currOtherTypeCallback, n = Object.hasOwn(r, "parent") ? r.parent : n, a = Object.hasOwn(r, "parentProperty") ? r.parentProperty : a, r = r.path;
+  }
+  if (n = n || null, a = a || null, Array.isArray(r) && (r = x.toPathString(r)), !r && r !== "" || !e)
+    return;
+  const u = x.toPathArray(r);
+  u[0] === "$" && u.length > 1 && u.shift(), this._hasParentSelector = null;
+  const h = this._trace(u, e, ["$"], n, a, t).filter(function(b) {
+    return b && !b.isParentSelector;
+  });
+  return h.length ? !d && h.length === 1 && !h[0].hasArrExpr ? this._getPreferredOutput(h[0]) : h.reduce((b, m) => {
+    const C = this._getPreferredOutput(m);
+    return c && Array.isArray(C) ? b = b.concat(C) : b.push(C), b;
+  }, []) : d ? [] : void 0;
+};
+x.prototype._getPreferredOutput = function(r) {
+  const e = this.currResultType;
+  switch (e) {
+    case "all": {
+      const t = Array.isArray(r.path) ? r.path : x.toPathArray(r.path);
+      return r.pointer = x.toPointer(t), r.path = typeof r.path == "string" ? r.path : x.toPathString(r.path), r;
+    }
+    case "value":
+    case "parent":
+    case "parentProperty":
+      return r[e];
+    case "path":
+      return x.toPathString(r[e]);
+    case "pointer":
+      return x.toPointer(r.path);
+    default:
+      throw new TypeError("Unknown result type");
+  }
+};
+x.prototype._handleCallback = function(r, e, t) {
+  if (e) {
+    const s = this._getPreferredOutput(r);
+    r.path = typeof r.path == "string" ? r.path : x.toPathString(r.path), e(s, t, r);
+  }
+};
+x.prototype._trace = function(r, e, t, s, n, a, c, d) {
+  let u;
+  if (!r.length)
+    return u = {
+      path: t,
+      value: e,
+      parent: s,
+      parentProperty: n,
+      hasArrExpr: c
+    }, this._handleCallback(u, a, "value"), u;
+  const h = r[0], b = r.slice(1), m = [];
+  function C(E) {
+    Array.isArray(E) ? E.forEach((S) => {
+      m.push(S);
+    }) : m.push(E);
+  }
+  if ((typeof h != "string" || d) && e && Object.hasOwn(e, h))
+    C(this._trace(b, e[h], F(t, h), e, h, a, c));
+  else if (h === "*")
+    this._walk(e, (E) => {
+      C(this._trace(b, e[E], F(t, E), e, E, a, !0, !0));
+    });
+  else if (h === "..")
+    C(this._trace(b, e, t, s, n, a, c)), this._walk(e, (E) => {
+      typeof e[E] == "object" && C(this._trace(r.slice(), e[E], F(t, E), e, E, a, !0));
+    });
+  else {
+    if (h === "^")
+      return this._hasParentSelector = !0, {
+        path: t.slice(0, -1),
+        expr: b,
+        isParentSelector: !0
+      };
+    if (h === "~")
+      return u = {
+        path: F(t, h),
+        value: n,
+        parent: s,
+        parentProperty: null
+      }, this._handleCallback(u, a, "property"), u;
+    if (h === "$")
+      C(this._trace(b, e, t, null, null, a, c));
+    else if (/^(-?\d*):(-?\d*):?(\d*)$/u.test(h))
+      C(this._slice(h, b, e, t, s, n, a));
+    else if (h.indexOf("?(") === 0) {
+      if (this.currEval === !1)
+        throw new Error("Eval [?(expr)] prevented in JSONPath expression.");
+      const E = h.replace(/^\?\((.*?)\)$/u, "$1"), S = /@.?([^?]*)[['](\??\(.*?\))(?!.\)\])[\]']/gu.exec(E);
+      S ? this._walk(e, (A) => {
+        const T = [S[2]], $ = S[1] ? e[A][S[1]] : e[A];
+        this._trace(T, $, t, s, n, a, !0).length > 0 && C(this._trace(b, e[A], F(t, A), e, A, a, !0));
+      }) : this._walk(e, (A) => {
+        this._eval(E, e[A], A, t, s, n) && C(this._trace(b, e[A], F(t, A), e, A, a, !0));
+      });
+    } else if (h[0] === "(") {
+      if (this.currEval === !1)
+        throw new Error("Eval [(expr)] prevented in JSONPath expression.");
+      C(this._trace(se(this._eval(h, e, t.at(-1), t.slice(0, -1), s, n), b), e, t, s, n, a, c));
+    } else if (h[0] === "@") {
+      let E = !1;
+      const S = h.slice(1, -2);
+      switch (S) {
+        case "scalar":
+          (!e || !["object", "function"].includes(typeof e)) && (E = !0);
+          break;
+        case "boolean":
+        case "string":
+        case "undefined":
+        case "function":
+          typeof e === S && (E = !0);
+          break;
+        case "integer":
+          Number.isFinite(e) && !(e % 1) && (E = !0);
+          break;
+        case "number":
+          Number.isFinite(e) && (E = !0);
+          break;
+        case "nonFinite":
+          typeof e == "number" && !Number.isFinite(e) && (E = !0);
+          break;
+        case "object":
+          e && typeof e === S && (E = !0);
+          break;
+        case "array":
+          Array.isArray(e) && (E = !0);
+          break;
+        case "other":
+          E = this.currOtherTypeCallback(e, t, s, n);
+          break;
+        case "null":
+          e === null && (E = !0);
+          break;
+        /* c8 ignore next 2 */
+        default:
+          throw new TypeError("Unknown value type " + S);
+      }
+      if (E)
+        return u = {
+          path: t,
+          value: e,
+          parent: s,
+          parentProperty: n
+        }, this._handleCallback(u, a, "value"), u;
+    } else if (h[0] === "`" && e && Object.hasOwn(e, h.slice(1))) {
+      const E = h.slice(1);
+      C(this._trace(b, e[E], F(t, E), e, E, a, c, !0));
+    } else if (h.includes(",")) {
+      const E = h.split(",");
+      for (const S of E)
+        C(this._trace(se(S, b), e, t, s, n, a, !0));
+    } else !d && e && Object.hasOwn(e, h) && C(this._trace(b, e[h], F(t, h), e, h, a, c, !0));
+  }
+  if (this._hasParentSelector)
+    for (let E = 0; E < m.length; E++) {
+      const S = m[E];
+      if (S && S.isParentSelector) {
+        const A = this._trace(S.expr, e, S.path, s, n, a, c);
+        if (Array.isArray(A)) {
+          m[E] = A[0];
+          const T = A.length;
+          for (let $ = 1; $ < T; $++)
+            E++, m.splice(E, 0, A[$]);
+        } else
+          m[E] = A;
+      }
+    }
+  return m;
+};
+x.prototype._walk = function(r, e) {
+  if (Array.isArray(r)) {
+    const t = r.length;
+    for (let s = 0; s < t; s++)
+      e(s);
+  } else r && typeof r == "object" && Object.keys(r).forEach((t) => {
+    e(t);
+  });
+};
+x.prototype._slice = function(r, e, t, s, n, a, c) {
+  if (!Array.isArray(t))
+    return;
+  const d = t.length, u = r.split(":"), h = u[2] && Number.parseInt(u[2]) || 1;
+  let b = u[0] && Number.parseInt(u[0]) || 0, m = u[1] && Number.parseInt(u[1]) || d;
+  b = b < 0 ? Math.max(0, b + d) : Math.min(d, b), m = m < 0 ? Math.max(0, m + d) : Math.min(d, m);
+  const C = [];
+  for (let E = b; E < m; E += h)
+    this._trace(se(E, e), t, s, n, a, c, !0).forEach((A) => {
+      C.push(A);
+    });
+  return C;
+};
+x.prototype._eval = function(r, e, t, s, n, a) {
+  this.currSandbox._$_parentProperty = a, this.currSandbox._$_parent = n, this.currSandbox._$_property = t, this.currSandbox._$_root = this.json, this.currSandbox._$_v = e;
+  const c = r.includes("@path");
+  c && (this.currSandbox._$_path = x.toPathString(s.concat([t])));
+  const d = this.currEval + "Script:" + r;
+  if (!x.cache[d]) {
+    let u = r.replaceAll("@parentProperty", "_$_parentProperty").replaceAll("@parent", "_$_parent").replaceAll("@property", "_$_property").replaceAll("@root", "_$_root").replaceAll(/@([.\s)[])/gu, "_$_v$1");
+    if (c && (u = u.replaceAll("@path", "_$_path")), this.currEval === "safe" || this.currEval === !0 || this.currEval === void 0)
+      x.cache[d] = new this.safeVm.Script(u);
+    else if (this.currEval === "native")
+      x.cache[d] = new this.vm.Script(u);
+    else if (typeof this.currEval == "function" && this.currEval.prototype && Object.hasOwn(this.currEval.prototype, "runInNewContext")) {
+      const h = this.currEval;
+      x.cache[d] = new h(u);
+    } else if (typeof this.currEval == "function")
+      x.cache[d] = {
+        runInNewContext: (h) => this.currEval(u, h)
+      };
+    else
+      throw new TypeError(`Unknown "eval" property "${this.currEval}"`);
+  }
+  try {
+    return x.cache[d].runInNewContext(this.currSandbox);
+  } catch (u) {
+    if (this.ignoreEvalErrors)
+      return !1;
+    throw new Error("jsonPath: " + u.message + ": " + r);
+  }
+};
+x.cache = {};
+x.toPathString = function(r) {
+  const e = r, t = e.length;
+  let s = "$";
+  for (let n = 1; n < t; n++)
+    /^(~|\^|@.*?\(\))$/u.test(e[n]) || (s += /^[0-9*]+$/u.test(e[n]) ? "[" + e[n] + "]" : "['" + e[n] + "']");
+  return s;
+};
+x.toPointer = function(r) {
+  const e = r, t = e.length;
+  let s = "";
+  for (let n = 1; n < t; n++)
+    /^(~|\^|@.*?\(\))$/u.test(e[n]) || (s += "/" + e[n].toString().replaceAll("~", "~0").replaceAll("/", "~1"));
+  return s;
+};
+x.toPathArray = function(r) {
+  const {
+    cache: e
+  } = x;
+  if (e[r])
+    return e[r].concat();
+  const t = [], n = r.replaceAll(/@(?:null|boolean|number|string|integer|undefined|nonFinite|scalar|array|object|function|other)\(\)/gu, ";$&;").replaceAll(/[['](\??\(.*?\))[\]'](?!.\])/gu, function(a, c) {
+    return "[#" + (t.push(c) - 1) + "]";
+  }).replaceAll(/\[['"]([^'\]]*)['"]\]/gu, function(a, c) {
+    return "['" + c.replaceAll(".", "%@%").replaceAll("~", "%%@@%%") + "']";
+  }).replaceAll("~", ";~;").replaceAll(/['"]?\.['"]?(?![^[]*\])|\[['"]?/gu, ";").replaceAll("%@%", ".").replaceAll("%%@@%%", "~").replaceAll(/(?:;)?(\^+)(?:;)?/gu, function(a, c) {
+    return ";" + c.split("").join(";") + ";";
+  }).replaceAll(/;;;|;;/gu, ";..;").replaceAll(/;$|'?\]|'$/gu, "").split(";").map(function(a) {
+    const c = a.match(/#(\d+)/u);
+    return !c || !c[1] ? a : t[c[1]];
+  });
+  return e[r] = n, e[r].concat();
+};
+x.prototype.safeVm = {
+  Script: we
+};
+const Se = function(r, e, t) {
+  const s = r.length;
+  for (let n = 0; n < s; n++) {
+    const a = r[n];
+    t(a) && e.push(r.splice(n--, 1)[0]);
+  }
+};
+class Pe {
+  /**
+   * @param {string} expr Expression to evaluate
+   */
+  constructor(e) {
+    this.code = e;
+  }
+  /**
+   * @param {object} context Object whose items will be added
+   *   to evaluation
+   * @returns {EvaluatedResult} Result of evaluated code
+   */
+  runInNewContext(e) {
+    let t = this.code;
+    const s = Object.keys(e), n = [];
+    Se(s, n, (h) => typeof e[h] == "function");
+    const a = s.map((h) => e[h]);
+    t = n.reduce((h, b) => {
+      let m = e[b].toString();
+      return /function/u.test(m) || (m = "function " + m), "var " + b + "=" + m + ";" + h;
+    }, "") + t, !/(['"])use strict\1/u.test(t) && !s.includes("arguments") && (t = "var arguments = undefined;" + t), t = t.replace(/;\s*$/u, "");
+    const d = t.lastIndexOf(";"), u = d !== -1 ? t.slice(0, d + 1) + " return " + t.slice(d + 1) : " return " + t;
+    return new Function(...s, u)(...a);
+  }
+}
+x.prototype.vm = {
+  Script: Pe
+};
+const Ne = { class: "json-node" }, De = {
   key: 0,
   class: "json-node__container"
-}, le = { class: "json-node__line" }, re = {
+}, je = { class: "json-node__line" }, Ie = {
   key: 2,
   class: "json-node__colon"
-}, ae = ["title"], ue = {
+}, $e = ["title"], Te = {
   key: 3,
   class: "json-node__collapsed"
-}, ie = {
+}, Re = {
   key: 4,
   class: "json-node__comma"
-}, ce = {
+}, Ue = {
   key: 0,
   class: "json-node__children"
-}, de = { class: "json-node__children-content" }, pe = { class: "json-node__line json-node__closing-bracket" }, fe = { class: "json-node__bracket" }, ve = {
+}, Be = { class: "json-node__children-content" }, Le = { class: "json-node__line json-node__closing-bracket" }, Me = { class: "json-node__bracket" }, Fe = {
   key: 0,
   class: "json-node__comma"
-}, _e = {
+}, Ve = {
   key: 1,
   class: "json-node__primitive"
-}, ye = {
+}, Ke = {
   key: 2,
   class: "json-node__colon"
-}, me = ["title"], ke = {
-  key: 5,
+}, Xe = ["title"], He = {
+  key: 0,
   class: "json-node__comma"
-}, ge = /* @__PURE__ */ z({
+}, Qe = /* @__PURE__ */ ae({
   name: "JsonNode",
   __name: "JsonNode",
   props: {
@@ -38,198 +1339,203 @@ const se = { class: "json-node" }, oe = {
     isLast: { type: Boolean, default: !1 }
   },
   emits: ["update:value", "toggle-expand", "copy", "update:key"],
-  setup(h, { emit: b }) {
-    Q((e) => ({
-      56869946: e.level
+  setup(r, { emit: e }) {
+    ue((f) => ({
+      "1f6d5aa6": f.level
     }));
-    const o = h, j = b, d = C(!1), p = C(!1), y = C(""), c = C(""), m = (e) => {
-      if (!/^-?\d+(\.\d+)?$/.test(e)) return !1;
-      const t = Number(e);
-      return !Number.isSafeInteger(t) || e.length > 15;
-    }, w = g(() => o.value !== null && typeof o.value == "object"), S = g(() => Array.isArray(o.value)), N = g(() => o.path ? o.path : o.keyName ? o.keyName : "root"), J = g(() => o.expanded.has(N.value)), x = g(() => o.keyName), I = g(() => S.value ? "[" : "{"), E = g(() => S.value ? "]" : "}"), F = g(() => {
-      if (!o.value) return "";
-      const t = Object.keys(o.value).length;
-      return S.value ? t > 0 ? ` ${t} items ` : " " : t > 0 ? ` ${t} keys ` : " ";
-    }), U = g(() => {
-      const e = typeof o.value;
-      return o.value === null ? "json-node__value--null" : e === "boolean" ? "json-node__value--boolean" : e === "number" ? "json-node__value--number" : e === "string" ? m(o.value) ? "json-node__value--number" : "json-node__value--string" : "";
-    }), T = g(() => p.value ? c.value : o.value === null ? "null" : typeof o.value == "boolean" || typeof o.value == "number" ? String(o.value) : typeof o.value == "string" ? m(o.value) ? o.value : `"${o.value}"` : String(o.value)), P = g(() => "Click to edit, double-click to copy"), L = (e) => o.level === 0 ? e : N.value ? `${N.value}.${e}` : e, M = (e) => {
-      const t = Object.keys(o.value);
-      return t.indexOf(e) === t.length - 1;
-    }, A = () => {
-      j("toggle-expand", N.value);
-    }, B = () => {
-      o.level !== 0 && (d.value = !0, y.value = o.keyName, K(() => {
-        const e = document.querySelectorAll(".json-node__key-input"), t = e[e.length - 1];
-        t && (t.focus(), t.select());
+    const t = r, s = e, n = B(!1), a = B(!1), c = B(""), d = B(""), u = (f) => {
+      if (!/^-?\d+(\.\d+)?$/.test(f)) return !1;
+      const v = Number(f);
+      return !Number.isSafeInteger(v) || f.length > 15;
+    }, h = j(() => t.value !== null && typeof t.value == "object"), b = j(() => Array.isArray(t.value)), m = j(() => t.path ? t.path : t.keyName ? t.keyName : "root"), C = j(() => t.expanded.has(m.value)), E = j(() => t.keyName), S = j(() => b.value ? "[" : "{"), A = j(() => b.value ? "]" : "}"), T = j(() => {
+      if (!t.value) return "";
+      const v = Object.keys(t.value).length;
+      return b.value ? v > 0 ? ` ${v} items ` : " " : v > 0 ? ` ${v} keys ` : " ";
+    }), $ = j(() => {
+      const f = typeof t.value;
+      return t.value === null ? "json-node__value--null" : f === "boolean" ? "json-node__value--boolean" : f === "number" ? "json-node__value--number" : f === "string" ? u(t.value) ? "json-node__value--number" : "json-node__value--string" : "";
+    }), q = j(() => a.value ? d.value : t.value === null ? "null" : typeof t.value == "boolean" || typeof t.value == "number" ? String(t.value) : typeof t.value == "string" ? u(t.value) ? t.value : `"${t.value}"` : String(t.value)), G = j(() => "Click to edit, double-click to copy"), K = (f) => t.level === 0 ? f : m.value ? `${m.value}.${f}` : f, z = (f) => {
+      const v = Object.keys(t.value);
+      return v.indexOf(f) === v.length - 1;
+    }, Q = () => {
+      s("toggle-expand", m.value);
+    }, Y = () => {
+      t.level !== 0 && (n.value = !0, c.value = t.keyName, ee(() => {
+        const f = document.querySelectorAll(".json-node__key-input"), v = f[f.length - 1];
+        v && (v.focus(), v.select());
       }));
-    }, D = () => {
-      w.value || (p.value = !0, typeof o.value == "string" && m(o.value) || typeof o.value == "string" ? c.value = o.value : c.value = String(o.value), K(() => {
-        const e = document.querySelectorAll(".json-node__value-input"), t = e[e.length - 1];
-        t && (t.focus(), t.select());
+    }, W = () => {
+      h.value || (a.value = !0, typeof t.value == "string" && u(t.value) || typeof t.value == "string" ? d.value = t.value : d.value = String(t.value), ee(() => {
+        const f = document.querySelectorAll(".json-node__value-input"), v = f[f.length - 1];
+        v && (v.focus(), v.select());
       }));
     }, V = () => {
-      if (o.level === 0 || !d.value) return;
-      const e = y.value.trim();
-      if (!e) {
-        s();
+      if (t.level === 0 || !n.value) return;
+      const f = c.value.trim();
+      if (!f) {
+        M();
         return;
       }
-      if (e === o.keyName) {
-        d.value = !1;
+      if (f === t.keyName) {
+        n.value = !1;
         return;
       }
-      d.value = !1, j("update:key", N.value, e);
-    }, n = () => {
+      n.value = !1, s("update:key", m.value, f);
+    }, Z = () => {
       try {
-        let e;
-        const t = c.value.trim();
-        if (t === "null")
-          e = null;
-        else if (t === "true" || t === "false")
-          e = t === "true";
-        else if (!isNaN(Number(t)) && t !== "") {
-          const l = Number(t);
-          !Number.isSafeInteger(l) || t.length > 15 ? e = t : e = l;
+        let f;
+        const v = d.value.trim();
+        if (v === "null")
+          f = null;
+        else if (v === "true" || v === "false")
+          f = v === "true";
+        else if (!isNaN(Number(v)) && v !== "") {
+          const o = Number(v);
+          !Number.isSafeInteger(o) || v.length > 15 ? f = v : f = o;
         } else
-          e = c.value;
-        j("update:value", N.value, e), p.value = !1;
-      } catch (e) {
-        console.error("Failed to parse value:", e), p.value = !1;
+          f = d.value;
+        s("update:value", m.value, f), a.value = !1;
+      } catch (f) {
+        console.error("Failed to parse value:", f), a.value = !1;
       }
-    }, s = () => {
-      d.value = !1, y.value = o.keyName;
-    }, r = () => {
-      p.value = !1, typeof o.value == "string" && m(o.value) || typeof o.value == "string" ? c.value = o.value : c.value = String(o.value);
+    }, M = () => {
+      n.value = !1, c.value = t.keyName;
+    }, J = () => {
+      a.value = !1, typeof t.value == "string" && u(t.value) || typeof t.value == "string" ? d.value = t.value : d.value = String(t.value);
     };
-    return (e, t) => {
-      const l = X("JsonNode", !0);
-      return u(), a("div", se, [
-        w.value ? (u(), a("div", oe, [
-          _("div", le, [
-            e.keyName && !d.value ? (u(), a("span", {
+    return (f, v) => {
+      const o = he("JsonNode", !0);
+      return k(), w("div", Ne, [
+        h.value ? (k(), w("div", De, [
+          P("div", je, [
+            f.keyName && !n.value ? (k(), w("span", {
               key: 0,
               class: "json-node__key",
-              onClick: B,
+              onClick: Y,
               title: "Click to edit key"
-            }, ' "' + $(x.value) + '" ', 1)) : k("", !0),
-            e.keyName && d.value ? R((u(), a("input", {
+            }, ' "' + U(E.value) + '" ', 1)) : N("", !0),
+            f.keyName && n.value ? te((k(), w("input", {
               key: 1,
-              "onUpdate:modelValue": t[0] || (t[0] = (i) => y.value = i),
+              "onUpdate:modelValue": v[0] || (v[0] = (l) => c.value = l),
               onKeyup: [
-                O(V, ["enter"]),
-                O(s, ["escape"])
+                X(V, ["enter"]),
+                X(M, ["escape"])
               ],
               onBlur: V,
               class: "json-node__key-input"
             }, null, 544)), [
-              [q, y.value]
-            ]) : k("", !0),
-            e.keyName ? (u(), a("span", re, ": ")) : k("", !0),
-            _("span", {
+              [re, c.value]
+            ]) : N("", !0),
+            f.keyName ? (k(), w("span", Ie, ": ")) : N("", !0),
+            P("span", {
               class: "json-node__bracket json-node__bracket--clickable",
-              onClick: A,
-              title: J.value ? "Click to collapse" : "Click to expand"
-            }, $(I.value), 9, ae),
-            J.value ? k("", !0) : (u(), a("span", ue, [
-              Y($(F.value) + " ", 1),
-              _("span", {
+              onClick: Q,
+              title: C.value ? "Click to collapse" : "Click to expand"
+            }, U(S.value), 9, $e),
+            C.value ? N("", !0) : (k(), w("span", Te, [
+              ie(U(T.value) + " ", 1),
+              P("span", {
                 class: "json-node__bracket json-node__bracket--clickable",
-                onClick: A
-              }, $(E.value), 1)
+                onClick: Q
+              }, U(A.value), 1)
             ])),
-            !J.value && !e.isLast ? (u(), a("span", ie, ",")) : k("", !0)
+            !C.value && !f.isLast ? (k(), w("span", Re, ",")) : N("", !0)
           ]),
-          J.value ? (u(), a("div", ce, [
-            _("div", de, [
-              (u(!0), a(Z, null, ee(e.value, (i, v) => (u(), a("div", {
-                key: v,
+          C.value ? (k(), w("div", Ue, [
+            P("div", Be, [
+              (k(!0), w(de, null, fe(f.value, (l, g) => (k(), w("div", {
+                key: g,
                 class: "json-node__child"
               }, [
-                W(l, {
-                  value: i,
-                  "key-name": S.value ? "" : String(v),
-                  level: e.level + 1,
-                  path: L(String(v)),
-                  expanded: e.expanded,
-                  "onUpdate:value": t[1] || (t[1] = (f, G) => e.$emit("update:value", f, G)),
-                  onToggleExpand: t[2] || (t[2] = (f) => e.$emit("toggle-expand", f)),
-                  onCopy: t[3] || (t[3] = (f) => e.$emit("copy", f)),
-                  "onUpdate:key": t[4] || (t[4] = (f, G) => e.$emit("update:key", f, G)),
-                  "is-last": M(String(v))
+                le(o, {
+                  value: l,
+                  "key-name": b.value ? "" : String(g),
+                  level: f.level + 1,
+                  path: K(String(g)),
+                  expanded: f.expanded,
+                  "onUpdate:value": v[1] || (v[1] = (p, y) => f.$emit("update:value", p, y)),
+                  onToggleExpand: v[2] || (v[2] = (p) => f.$emit("toggle-expand", p)),
+                  onCopy: v[3] || (v[3] = (p) => f.$emit("copy", p)),
+                  "onUpdate:key": v[4] || (v[4] = (p, y) => f.$emit("update:key", p, y)),
+                  "is-last": z(String(g))
                 }, null, 8, ["value", "key-name", "level", "path", "expanded", "is-last"])
               ]))), 128))
             ]),
-            _("div", pe, [
-              _("span", fe, $(E.value), 1),
-              e.isLast ? k("", !0) : (u(), a("span", ve, ","))
+            P("div", Le, [
+              P("span", Me, U(A.value), 1),
+              f.isLast ? N("", !0) : (k(), w("span", Fe, ","))
             ])
-          ])) : k("", !0)
-        ])) : (u(), a("div", _e, [
-          e.keyName && !d.value ? (u(), a("span", {
+          ])) : N("", !0)
+        ])) : (k(), w("div", Ve, [
+          f.keyName && !n.value ? (k(), w("span", {
             key: 0,
             class: "json-node__key",
-            onClick: B,
+            onClick: Y,
             title: "Click to edit key"
-          }, ' "' + $(x.value) + '" ', 1)) : k("", !0),
-          e.keyName && d.value ? R((u(), a("input", {
+          }, ' "' + U(E.value) + '" ', 1)) : N("", !0),
+          f.keyName && n.value ? te((k(), w("input", {
             key: 1,
-            "onUpdate:modelValue": t[5] || (t[5] = (i) => y.value = i),
+            "onUpdate:modelValue": v[5] || (v[5] = (l) => c.value = l),
             onKeyup: [
-              O(V, ["enter"]),
-              O(s, ["escape"])
+              X(V, ["enter"]),
+              X(M, ["escape"])
             ],
             onBlur: V,
             class: "json-node__key-input"
           }, null, 544)), [
-            [q, y.value]
-          ]) : k("", !0),
-          e.keyName ? (u(), a("span", ye, ": ")) : k("", !0),
-          p.value ? k("", !0) : (u(), a("span", {
+            [re, c.value]
+          ]) : N("", !0),
+          f.keyName ? (k(), w("span", Ke, ": ")) : N("", !0),
+          a.value ? N("", !0) : (k(), w("span", {
             key: 3,
-            class: te(["json-node__value", U.value]),
-            onClick: D,
-            onDblclick: t[6] || (t[6] = (i) => e.$emit("copy", e.value)),
-            title: P.value
-          }, $(T.value), 43, me)),
-          p.value ? R((u(), a("input", {
+            class: pe(["json-node__value", $.value]),
+            onClick: W,
+            onDblclick: v[6] || (v[6] = (l) => f.$emit("copy", f.value)),
+            title: G.value
+          }, [
+            ie(U(q.value), 1),
+            f.isLast ? N("", !0) : (k(), w("span", He, ","))
+          ], 42, Xe)),
+          a.value ? te((k(), w("input", {
             key: 4,
-            "onUpdate:modelValue": t[7] || (t[7] = (i) => c.value = i),
+            "onUpdate:modelValue": v[7] || (v[7] = (l) => d.value = l),
             onKeyup: [
-              O(n, ["enter"]),
-              O(r, ["escape"])
+              X(Z, ["enter"]),
+              X(J, ["escape"])
             ],
-            onBlur: n,
+            onBlur: Z,
             class: "json-node__value-input"
           }, null, 544)), [
-            [q, c.value]
-          ]) : k("", !0),
-          e.isLast ? k("", !0) : (u(), a("span", ke, ","))
+            [re, d.value]
+          ]) : N("", !0)
         ]))
       ]);
     };
   }
-}), H = (h, b) => {
-  const o = h.__vccOpts || h;
-  for (const [j, d] of b)
-    o[j] = d;
-  return o;
-}, Ne = /* @__PURE__ */ H(ge, [["__scopeId", "data-v-5a60a3b2"]]), be = { class: "json-format" }, je = {
+}), ce = (r, e) => {
+  const t = r.__vccOpts || r;
+  for (const [s, n] of e)
+    t[s] = n;
+  return t;
+}, Ye = /* @__PURE__ */ ce(Qe, [["__scopeId", "data-v-fdfd4b42"]]), qe = { class: "json-format" }, Ge = {
   key: 0,
   class: "json-format__toolbar"
-}, he = { class: "json-format__actions" }, $e = ["disabled"], Se = ["disabled"], Je = ["disabled"], Ae = ["disabled"], Ce = { class: "json-format__info" }, Ee = {
+}, ze = { class: "json-format__actions" }, We = ["disabled"], Ze = ["disabled"], Je = ["disabled"], et = ["disabled"], tt = { class: "json-format__info" }, rt = {
   key: 0,
   class: "json-format__status json-format__status--success"
-}, Ve = {
+}, nt = {
   key: 1,
   class: "json-format__status json-format__status--error"
-}, Oe = { class: "json-format__content" }, we = {
+}, st = { class: "json-format__content" }, it = {
   key: 0,
   class: "json-format__error"
-}, Be = {
+}, ot = {
   key: 1,
+  class: "json-format__error"
+}, at = {
+  key: 2,
   class: "json-format__viewer"
-}, xe = /* @__PURE__ */ z({
+}, lt = /* @__PURE__ */ ae({
   name: "JsonFormat",
   __name: "index",
   props: {
@@ -239,241 +1545,280 @@ const se = { class: "json-node" }, oe = {
     showToolbar: { type: Boolean, default: !0 }
   },
   emits: ["update:modelValue", "copy-success", "copy-error", "expand-all", "collapse-all", "compress"],
-  setup(h, { expose: b, emit: o }) {
-    const j = h, d = o, p = C(null), y = C(""), c = C(/* @__PURE__ */ new Set()), m = g(() => y.value === ""), w = (n) => {
-      if (!n.trim()) {
-        p.value = null, y.value = "";
+  setup(r, { expose: e, emit: t }) {
+    const s = r, n = t, a = B(null), c = B(""), d = B(/* @__PURE__ */ new Set()), u = B(null), h = B(""), b = j(() => c.value === ""), m = j(() => h.value ? null : u.value !== null ? u.value : a.value), C = (o) => {
+      if (!o.trim()) {
+        a.value = null, c.value = "", u.value = null, h.value = "";
+        return;
+      }
+      try {
+        let l = o;
+        l = l.replace(/:\s*(\d{16,})\s*([,}])/g, ': "$1"$2'), l = l.replace(/:\s*(\d+\.\d*?0+)\s*([,}])/g, ': "$1"$2'), a.value = JSON.parse(l), c.value = "", u.value = null, h.value = "", ee(() => {
+          m.value !== null && K();
+        });
+      } catch (l) {
+        c.value = l instanceof Error ? l.message : "Unknown parsing error", a.value = null, u.value = null, h.value = "";
+      }
+    }, E = (o) => {
+      if (!o || !o.expression.trim()) {
+        S();
+        return;
+      }
+      if (!a.value) {
+        h.value = "No valid JSON data to filter";
         return;
       }
       try {
-        let s = n;
-        s = s.replace(/:\s*(\d{16,})\s*([,}])/g, ': "$1"$2'), s = s.replace(/:\s*(\d+\.\d*?0+)\s*([,}])/g, ': "$1"$2'), p.value = JSON.parse(s), y.value = "", K(() => {
-          p.value !== null && E();
+        let l;
+        if (o.type === "jsonpath")
+          l = x({ path: o.expression, json: a.value }), l.length === 1 && o.expression.includes("$[") === !1 && !o.expression.endsWith("[*]") ? u.value = l[0] : u.value = l;
+        else if (o.type === "js")
+          l = new Function("data", `
+        try {
+          return ${o.expression};
+        } catch (error) {
+          throw new Error('JavaScript expression error: ' + error.message);
+        }
+      `)(a.value), u.value = l;
+        else
+          throw new Error(`Unsupported filter type: ${o.type}`);
+        h.value = "", ee(() => {
+          K();
         });
-      } catch (s) {
-        y.value = s instanceof Error ? s.message : "Unknown parsing error", p.value = null;
+      } catch (l) {
+        h.value = l instanceof Error ? l.message : "Filter execution error", u.value = null;
       }
+    }, S = () => {
+      u.value = null, h.value = "";
     };
-    ne(() => j.modelValue, (n) => {
-      w(n);
+    ye(() => s.modelValue, (o) => {
+      C(o);
     }, { immediate: !0 });
-    const S = (n) => {
-      if (!/^-?\d+(\.\d+)?$/.test(n)) return !1;
-      const s = Number(n);
-      return !Number.isSafeInteger(s) || n.length > 15;
-    }, N = (n, s, r) => JSON.stringify(n, (e, t) => {
-      if (typeof t == "string" && S(t))
-        return `__BIG_NUMBER__${t}__BIG_NUMBER__`;
-      if (typeof t == "string" && /^-?\d+(\.\d+)?$/.test(t)) {
-        const l = Number(t);
-        if (Number.isSafeInteger(l) && l.toString() === t)
-          return l;
-        if (!Number.isNaN(l) && isFinite(l) && t.includes("."))
-          return l.toString() === t ? l : t;
-        if (!Number.isNaN(l) && isFinite(l))
-          return l;
+    const A = (o) => {
+      if (!/^-?\d+(\.\d+)?$/.test(o)) return !1;
+      const l = Number(o);
+      return !Number.isSafeInteger(l) || o.length > 15;
+    }, T = (o, l, g) => JSON.stringify(o, (p, y) => {
+      if (typeof y == "string" && A(y))
+        return `__BIG_NUMBER__${y}__BIG_NUMBER__`;
+      if (typeof y == "string" && /^-?\d+(\.\d+)?$/.test(y)) {
+        const _ = Number(y);
+        if (Number.isSafeInteger(_) && _.toString() === y)
+          return _;
+        if (!Number.isNaN(_) && isFinite(_) && y.includes("."))
+          return _.toString() === y ? _ : y;
+        if (!Number.isNaN(_) && isFinite(_))
+          return _;
       }
-      return s && typeof s == "function" ? s(e, t) : t;
-    }, r).replace(/"__BIG_NUMBER__(.+?)__BIG_NUMBER__"/g, "$1"), J = (n, s) => {
-      if (!j.readonly)
+      return l && typeof l == "function" ? l(p, y) : y;
+    }, g).replace(/"__BIG_NUMBER__(.+?)__BIG_NUMBER__"/g, "$1"), $ = (o, l) => {
+      if (!s.readonly)
         try {
-          const r = x(p.value, n, s), e = N(r, null, 2);
-          d("update:modelValue", e);
-        } catch (r) {
-          console.error("Failed to update JSON:", r);
+          const g = q(a.value, o, l), p = T(g, null, 2);
+          n("update:modelValue", p);
+        } catch (g) {
+          console.error("Failed to update JSON:", g);
         }
-    }, x = (n, s, r) => {
-      if (!s || s === "root") return r;
-      const e = s.split("."), t = A(n, e.slice(0, -1));
-      let l = t;
-      for (let v = 0; v < e.length - 1; v++) {
-        const f = e[v];
-        f !== "root" && (Array.isArray(l) ? l = l[parseInt(f)] : l = l[f]);
+    }, q = (o, l, g) => {
+      if (!l || l === "root") return g;
+      const p = l.split("."), y = M(o, p.slice(0, -1));
+      let _ = y;
+      for (let I = 0; I < p.length - 1; I++) {
+        const R = p[I];
+        R !== "root" && (Array.isArray(_) ? _ = _[parseInt(R)] : _ = _[R]);
       }
-      const i = e[e.length - 1];
-      return i === "root" ? r : (Array.isArray(l) ? l[parseInt(i)] = r : l[i] = r, t);
-    }, I = (n) => {
-      c.value.has(n) ? c.value.delete(n) : c.value.add(n);
-    }, E = () => {
-      const n = /* @__PURE__ */ new Set(), s = (r, e = "") => {
-        r !== null && typeof r == "object" && (n.add(e || "root"), Array.isArray(r) ? r.forEach((t, l) => {
-          const i = e ? `${e}.${l}` : `${l}`;
-          s(t, i);
-        }) : Object.keys(r).forEach((t) => {
-          const l = e ? `${e}.${t}` : t;
-          s(r[t], l);
+      const D = p[p.length - 1];
+      return D === "root" ? g : (Array.isArray(_) ? _[parseInt(D)] = g : _[D] = g, y);
+    }, G = (o) => {
+      d.value.has(o) ? d.value.delete(o) : d.value.add(o);
+    }, K = () => {
+      const o = /* @__PURE__ */ new Set(), l = (g, p = "") => {
+        g !== null && typeof g == "object" && (o.add(p || "root"), Array.isArray(g) ? g.forEach((y, _) => {
+          const D = p ? `${p}.${_}` : `${_}`;
+          l(y, D);
+        }) : Object.keys(g).forEach((y) => {
+          const _ = p ? `${p}.${y}` : y;
+          l(g[y], _);
         }));
       };
-      s(p.value), c.value = n, d("expand-all");
-    }, F = () => {
-      c.value = /* @__PURE__ */ new Set(["root"]), d("collapse-all");
-    }, U = async () => {
-      if (m.value)
+      l(m.value), d.value = o, n("expand-all");
+    }, z = () => {
+      d.value = /* @__PURE__ */ new Set(["root"]), n("collapse-all");
+    }, Q = async () => {
+      if (b.value)
         try {
-          const s = JSON.stringify(p.value, null, 2).replace(/"(\d{16,})"/g, "$1");
-          await navigator.clipboard.writeText(s), d("copy-success", s);
-        } catch (n) {
-          console.error("Failed to copy JSON:", n), d("copy-error", n instanceof Error ? n : new Error("Failed to copy JSON"));
+          const o = m.value, g = JSON.stringify(o, null, 2).replace(/"(\d{16,})"/g, "$1");
+          await navigator.clipboard.writeText(g), n("copy-success", g);
+        } catch (o) {
+          console.error("Failed to copy JSON:", o), n("copy-error", o instanceof Error ? o : new Error("Failed to copy JSON"));
         }
-    }, T = () => {
-      if (m.value)
+    }, Y = () => {
+      if (b.value)
         try {
-          const n = N(p.value);
-          d("update:modelValue", n), d("compress", n);
-        } catch (n) {
-          console.error("Failed to compress JSON:", n);
+          const o = m.value, l = T(o);
+          n("update:modelValue", l), n("compress", l);
+        } catch (o) {
+          console.error("Failed to compress JSON:", o);
         }
-    }, P = async (n) => {
+    }, W = async (o) => {
       try {
-        let s;
-        typeof n == "string" && S(n) ? s = n : typeof n == "string" ? s = `"${n}"` : s = JSON.stringify(n), await navigator.clipboard.writeText(s);
-      } catch (s) {
-        console.error("Failed to copy value:", s);
+        let l;
+        typeof o == "string" && A(o) ? l = o : typeof o == "string" ? l = `"${o}"` : l = JSON.stringify(o), await navigator.clipboard.writeText(l);
+      } catch (l) {
+        console.error("Failed to copy value:", l);
       }
-    }, L = (n, s) => {
-      if (!j.readonly)
+    }, V = (o, l) => {
+      if (!s.readonly)
         try {
-          const r = M(p.value, n, s), e = N(r, null, 2);
-          d("update:modelValue", e), V(n, s);
-        } catch (r) {
-          console.error("Failed to rename key:", r);
+          const g = Z(a.value, o, l), p = T(g, null, 2);
+          n("update:modelValue", p), v(o, l);
+        } catch (g) {
+          console.error("Failed to rename key:", g);
         }
-    }, M = (n, s, r) => {
-      if (!s || s === "root") return n;
-      const e = s.split("."), t = A(n, e.slice(0, -1));
-      if (e.length === 1) {
-        const v = e[0];
-        return t && typeof t == "object" && !Array.isArray(t) ? B(t, v, r) : t;
+    }, Z = (o, l, g) => {
+      if (!l || l === "root") return o;
+      const p = l.split("."), y = M(o, p.slice(0, -1));
+      if (p.length === 1) {
+        const I = p[0];
+        return y && typeof y == "object" && !Array.isArray(y) ? J(y, I, g) : y;
       }
-      let l = t;
-      for (let v = 0; v < e.length - 1; v++) {
-        const f = e[v];
-        Array.isArray(l) ? l = l[parseInt(f)] : l = l[f];
+      let _ = y;
+      for (let I = 0; I < p.length - 1; I++) {
+        const R = p[I];
+        Array.isArray(_) ? _ = _[parseInt(R)] : _ = _[R];
       }
-      const i = e[e.length - 1];
-      if (!Array.isArray(l) && l && typeof l == "object") {
-        const v = B(l, i, r), f = e.slice(0, -1);
-        f.length > 0 && D(t, f, v);
+      const D = p[p.length - 1];
+      if (!Array.isArray(_) && _ && typeof _ == "object") {
+        const I = J(_, D, g), R = p.slice(0, -1);
+        R.length > 0 && f(y, R, I);
       }
-      return t;
-    }, A = (n, s) => {
-      if (s.length === 0) return n;
-      if (Array.isArray(n)) {
-        const r = [...n], e = s[0], t = parseInt(e);
-        return s.length === 1 || (r[t] = A(n[t], s.slice(1))), r;
-      } else if (n && typeof n == "object") {
-        const r = { ...n }, e = s[0];
-        return s.length === 1 || (r[e] = A(n[e], s.slice(1))), r;
+      return y;
+    }, M = (o, l) => {
+      if (l.length === 0) return o;
+      if (Array.isArray(o)) {
+        const g = [...o], p = l[0], y = parseInt(p);
+        return l.length === 1 || (g[y] = M(o[y], l.slice(1))), g;
+      } else if (o && typeof o == "object") {
+        const g = { ...o }, p = l[0];
+        return l.length === 1 || (g[p] = M(o[p], l.slice(1))), g;
       }
-      return n;
-    }, B = (n, s, r) => {
-      if (!n || typeof n != "object" || Array.isArray(n))
-        return n;
-      const e = Object.keys(n), t = {};
-      for (const l of e)
-        l === s ? t[r] = n[l] : t[l] = n[l];
-      return t;
-    }, D = (n, s, r) => {
-      let e = n;
-      for (let l = 0; l < s.length - 1; l++) {
-        const i = s[l];
-        Array.isArray(e) ? e = e[parseInt(i)] : e = e[i];
+      return o;
+    }, J = (o, l, g) => {
+      if (!o || typeof o != "object" || Array.isArray(o))
+        return o;
+      const p = Object.keys(o), y = {};
+      for (const _ of p)
+        _ === l ? y[g] = o[_] : y[_] = o[_];
+      return y;
+    }, f = (o, l, g) => {
+      let p = o;
+      for (let _ = 0; _ < l.length - 1; _++) {
+        const D = l[_];
+        Array.isArray(p) ? p = p[parseInt(D)] : p = p[D];
       }
-      const t = s[s.length - 1];
-      Array.isArray(e) ? e[parseInt(t)] = r : e[t] = r;
-    }, V = (n, s) => {
-      const r = /* @__PURE__ */ new Set();
-      c.value.forEach((e) => {
-        if (e === n) {
-          const t = n.split(".");
-          t[t.length - 1] = s, r.add(t.join("."));
-        } else if (e.startsWith(n + ".")) {
-          const t = n.split(".");
-          t[t.length - 1] = s;
-          const l = t.join("."), i = e.substring(n.length);
-          r.add(l + i);
+      const y = l[l.length - 1];
+      Array.isArray(p) ? p[parseInt(y)] = g : p[y] = g;
+    }, v = (o, l) => {
+      const g = /* @__PURE__ */ new Set();
+      d.value.forEach((p) => {
+        if (p === o) {
+          const y = o.split(".");
+          y[y.length - 1] = l, g.add(y.join("."));
+        } else if (p.startsWith(o + ".")) {
+          const y = o.split(".");
+          y[y.length - 1] = l;
+          const _ = y.join("."), D = p.substring(o.length);
+          g.add(_ + D);
         } else
-          r.add(e);
-      }), c.value = r;
+          g.add(p);
+      }), d.value = g;
     };
-    return b({
+    return e({
       // 核心操作方法
-      copyJson: U,
-      compressSource: T,
-      expandAll: E,
-      collapseAll: F,
-      toggleExpand: I,
-      updateValue: J,
-      updateKey: L,
+      copyJson: Q,
+      compressSource: Y,
+      expandAll: K,
+      collapseAll: z,
+      toggleExpand: G,
+      updateValue: $,
+      updateKey: V,
+      // Filter 相关方法
+      filter: E,
+      clearFilter: S,
       // 状态访问方法
-      isValidJson: () => m.value,
-      getParsedJson: () => p.value,
-      getExpandedNodes: () => c.value,
-      getParseError: () => y.value,
+      isValidJson: () => b.value,
+      getParsedJson: () => a.value,
+      getFilteredJson: () => u.value,
+      getExpandedNodes: () => d.value,
+      getParseError: () => c.value,
+      getFilterError: () => h.value,
       // 工具方法
-      parseJson: (n) => w(n),
-      copyValue: (n) => P(n)
-    }), (n, s) => (u(), a("div", be, [
-      n.showToolbar ? (u(), a("div", je, [
-        _("div", he, [
-          _("button", {
+      parseJson: (o) => C(o),
+      copyValue: (o) => W(o)
+    }), (o, l) => (k(), w("div", qe, [
+      o.showToolbar ? (k(), w("div", Ge, [
+        P("div", ze, [
+          P("button", {
             class: "json-format__btn json-format__btn--primary",
-            onClick: U,
-            disabled: !m.value,
+            onClick: Q,
+            disabled: !b.value,
             title: "Copy JSON"
-          }, " 📋 Copy ", 8, $e),
-          _("button", {
+          }, " 📋 Copy ", 8, We),
+          P("button", {
             class: "json-format__btn json-format__btn--secondary",
-            onClick: E,
-            disabled: !m.value,
+            onClick: K,
+            disabled: !b.value,
             title: "Expand All"
-          }, " ⬇️ Expand All ", 8, Se),
-          _("button", {
+          }, " ⬇️ Expand All ", 8, Ze),
+          P("button", {
             class: "json-format__btn json-format__btn--secondary",
-            onClick: F,
-            disabled: !m.value,
+            onClick: z,
+            disabled: !b.value,
             title: "Collapse All"
           }, " ➡️ Collapse All ", 8, Je),
-          _("button", {
+          P("button", {
             class: "json-format__btn json-format__btn--secondary",
-            onClick: T,
-            disabled: !m.value,
+            onClick: Y,
+            disabled: !b.value,
             title: "Compress JSON"
-          }, " 📦 Compress ", 8, Ae)
+          }, " 📦 Compress ", 8, et)
         ]),
-        _("div", Ce, [
-          m.value ? (u(), a("span", Ee, " ✅ Valid JSON ")) : (u(), a("span", Ve, " ❌ Invalid JSON "))
+        P("div", tt, [
+          b.value ? (k(), w("span", rt, " ✅ Valid JSON ")) : (k(), w("span", nt, " ❌ Invalid JSON "))
         ])
-      ])) : k("", !0),
-      _("div", Oe, [
-        m.value ? (u(), a("div", Be, [
-          W(Ne, {
-            value: p.value,
+      ])) : N("", !0),
+      P("div", st, [
+        b.value ? h.value ? (k(), w("div", ot, [
+          l[1] || (l[1] = P("h4", null, "Filter Error:", -1)),
+          P("pre", null, U(h.value), 1)
+        ])) : (k(), w("div", at, [
+          le(Ye, {
+            value: m.value,
             "key-name": "",
             level: 0,
-            expanded: c.value,
+            expanded: d.value,
             "is-last": !0,
-            "onUpdate:value": J,
-            onToggleExpand: I,
-            onCopy: P,
-            "onUpdate:key": L
+            "onUpdate:value": $,
+            onToggleExpand: G,
+            onCopy: W,
+            "onUpdate:key": V
           }, null, 8, ["value", "expanded"])
-        ])) : (u(), a("div", we, [
-          s[0] || (s[0] = _("h4", null, "JSON Parse Error:", -1)),
-          _("pre", null, $(y.value), 1)
+        ])) : (k(), w("div", it, [
+          l[0] || (l[0] = P("h4", null, "JSON Parse Error:", -1)),
+          P("pre", null, U(c.value), 1)
         ]))
       ])
     ]));
   }
-}), Ie = /* @__PURE__ */ H(xe, [["__scopeId", "data-v-e91f0005"]]), Fe = [Ie], Ue = (h) => {
-  Fe.forEach((b) => {
-    const o = b.name || b.__name || "UnknownComponent";
-    h.component(o, b);
+}), ct = /* @__PURE__ */ ce(lt, [["__scopeId", "data-v-c212b38f"]]), ut = [ct], ht = (r) => {
+  ut.forEach((e) => {
+    const t = e.name || e.__name || "UnknownComponent";
+    r.component(t, e);
   });
-}, Pe = {
-  install: Ue
+}, pt = {
+  install: ht
 };
 export {
-  Ie as JsonFormat,
-  Pe as default
+  ct as JsonFormat,
+  pt as default
 };