hldesigner 0.0.1

package/index-7fa591e3.js

@@ -0,0 +1,4817 @@
+import { c as pt } from "./_commonjsHelpers-e7ea1525.js";
+import { j as je } from "./baseImp-8c4be88e.js";
+var We = {}, ir = {
+  get exports() {
+    return We;
+  },
+  set exports(r) {
+    We = r;
+  }
+};
+/*! jsonpath 1.1.1 */
+(function(r, i) {
+  (function(n) {
+    r.exports = n();
+  })(function() {
+    return function n(o, h, s) {
+      function c(C, m) {
+        if (!h[C]) {
+          if (!o[C]) {
+            var p = typeof je == "function" && je;
+            if (!m && p)
+              return p(C, !0);
+            if (x)
+              return x(C, !0);
+            var y = new Error("Cannot find module '" + C + "'");
+            throw y.code = "MODULE_NOT_FOUND", y;
+          }
+          var F = h[C] = { exports: {} };
+          o[C][0].call(F.exports, function(d) {
+            var E = o[C][1][d];
+            return c(E || d);
+          }, F, F.exports, n, o, h, s);
+        }
+        return h[C].exports;
+      }
+      for (var x = typeof je == "function" && je, v = 0; v < s.length; v++)
+        c(s[v]);
+      return c;
+    }({ "./aesprim": [function(n, o, h) {
+      (function(s, c) {
+        c(typeof h < "u" ? h : s.esprima = {});
+      })(this, function(s) {
+        var c, x, v, C, m, p, y, F, d, E, u, S, B, D, a, f, b, g;
+        c = {
+          BooleanLiteral: 1,
+          EOF: 2,
+          Identifier: 3,
+          Keyword: 4,
+          NullLiteral: 5,
+          NumericLiteral: 6,
+          Punctuator: 7,
+          StringLiteral: 8,
+          RegularExpression: 9
+        }, x = {}, x[c.BooleanLiteral] = "Boolean", x[c.EOF] = "<end>", x[c.Identifier] = "Identifier", x[c.Keyword] = "Keyword", x[c.NullLiteral] = "Null", x[c.NumericLiteral] = "Numeric", x[c.Punctuator] = "Punctuator", x[c.StringLiteral] = "String", x[c.RegularExpression] = "RegularExpression", v = [
+          "(",
+          "{",
+          "[",
+          "in",
+          "typeof",
+          "instanceof",
+          "new",
+          "return",
+          "case",
+          "delete",
+          "throw",
+          "void",
+          // assignment operators
+          "=",
+          "+=",
+          "-=",
+          "*=",
+          "/=",
+          "%=",
+          "<<=",
+          ">>=",
+          ">>>=",
+          "&=",
+          "|=",
+          "^=",
+          ",",
+          // binary/unary operators
+          "+",
+          "-",
+          "*",
+          "/",
+          "%",
+          "++",
+          "--",
+          "<<",
+          ">>",
+          ">>>",
+          "&",
+          "|",
+          "^",
+          "!",
+          "~",
+          "&&",
+          "||",
+          "?",
+          ":",
+          "===",
+          "==",
+          ">=",
+          "<=",
+          "<",
+          ">",
+          "!=",
+          "!=="
+        ], C = {
+          AssignmentExpression: "AssignmentExpression",
+          ArrayExpression: "ArrayExpression",
+          BlockStatement: "BlockStatement",
+          BinaryExpression: "BinaryExpression",
+          BreakStatement: "BreakStatement",
+          CallExpression: "CallExpression",
+          CatchClause: "CatchClause",
+          ConditionalExpression: "ConditionalExpression",
+          ContinueStatement: "ContinueStatement",
+          DoWhileStatement: "DoWhileStatement",
+          DebuggerStatement: "DebuggerStatement",
+          EmptyStatement: "EmptyStatement",
+          ExpressionStatement: "ExpressionStatement",
+          ForStatement: "ForStatement",
+          ForInStatement: "ForInStatement",
+          FunctionDeclaration: "FunctionDeclaration",
+          FunctionExpression: "FunctionExpression",
+          Identifier: "Identifier",
+          IfStatement: "IfStatement",
+          Literal: "Literal",
+          LabeledStatement: "LabeledStatement",
+          LogicalExpression: "LogicalExpression",
+          MemberExpression: "MemberExpression",
+          NewExpression: "NewExpression",
+          ObjectExpression: "ObjectExpression",
+          Program: "Program",
+          Property: "Property",
+          ReturnStatement: "ReturnStatement",
+          SequenceExpression: "SequenceExpression",
+          SwitchStatement: "SwitchStatement",
+          SwitchCase: "SwitchCase",
+          ThisExpression: "ThisExpression",
+          ThrowStatement: "ThrowStatement",
+          TryStatement: "TryStatement",
+          UnaryExpression: "UnaryExpression",
+          UpdateExpression: "UpdateExpression",
+          VariableDeclaration: "VariableDeclaration",
+          VariableDeclarator: "VariableDeclarator",
+          WhileStatement: "WhileStatement",
+          WithStatement: "WithStatement"
+        }, m = {
+          Data: 1,
+          Get: 2,
+          Set: 4
+        }, p = {
+          UnexpectedToken: "Unexpected token %0",
+          UnexpectedNumber: "Unexpected number",
+          UnexpectedString: "Unexpected string",
+          UnexpectedIdentifier: "Unexpected identifier",
+          UnexpectedReserved: "Unexpected reserved word",
+          UnexpectedEOS: "Unexpected end of input",
+          NewlineAfterThrow: "Illegal newline after throw",
+          InvalidRegExp: "Invalid regular expression",
+          UnterminatedRegExp: "Invalid regular expression: missing /",
+          InvalidLHSInAssignment: "Invalid left-hand side in assignment",
+          InvalidLHSInForIn: "Invalid left-hand side in for-in",
+          MultipleDefaultsInSwitch: "More than one default clause in switch statement",
+          NoCatchOrFinally: "Missing catch or finally after try",
+          UnknownLabel: "Undefined label '%0'",
+          Redeclaration: "%0 '%1' has already been declared",
+          IllegalContinue: "Illegal continue statement",
+          IllegalBreak: "Illegal break statement",
+          IllegalReturn: "Illegal return statement",
+          StrictModeWith: "Strict mode code may not include a with statement",
+          StrictCatchVariable: "Catch variable may not be eval or arguments in strict mode",
+          StrictVarName: "Variable name may not be eval or arguments in strict mode",
+          StrictParamName: "Parameter name eval or arguments is not allowed in strict mode",
+          StrictParamDupe: "Strict mode function may not have duplicate parameter names",
+          StrictFunctionName: "Function name may not be eval or arguments in strict mode",
+          StrictOctalLiteral: "Octal literals are not allowed in strict mode.",
+          StrictDelete: "Delete of an unqualified identifier in strict mode.",
+          StrictDuplicateProperty: "Duplicate data property in object literal not allowed in strict mode",
+          AccessorDataProperty: "Object literal may not have data and accessor property with the same name",
+          AccessorGetSet: "Object literal may not have multiple get/set accessors with the same name",
+          StrictLHSAssignment: "Assignment to eval or arguments is not allowed in strict mode",
+          StrictLHSPostfix: "Postfix increment/decrement may not have eval or arguments operand in strict mode",
+          StrictLHSPrefix: "Prefix increment/decrement may not have eval or arguments operand in strict mode",
+          StrictReservedWord: "Use of future reserved word in strict mode"
+        }, y = {
+          NonAsciiIdentifierStart: new RegExp("[ªµºÀ-ÖØ-öø-ˁˆ-ˑˠ-ˤˬˮͰ-ʹͶͷͺ-ͽΆΈ-ΊΌΎ-ΡΣ-ϵϷ-ҁҊ-ԧԱ-Ֆՙա-ևא-תװ-ײؠ-يٮٯٱ-ۓەۥۦۮۯۺ-ۼۿܐܒ-ܯݍ-ޥޱߊ-ߪߴߵߺࠀ-ࠕࠚࠤࠨࡀ-ࡘࢠࢢ-ࢬऄ-हऽॐक़-ॡॱ-ॷॹ-ॿঅ-ঌএঐও-নপ-রলশ-হঽৎড়ঢ়য়-ৡৰৱਅ-ਊਏਐਓ-ਨਪ-ਰਲਲ਼ਵਸ਼ਸਹਖ਼-ੜਫ਼ੲ-ੴઅ-ઍએ-ઑઓ-નપ-રલળવ-હઽૐૠૡଅ-ଌଏଐଓ-ନପ-ରଲଳଵ-ହଽଡ଼ଢ଼ୟ-ୡୱஃஅ-ஊஎ-ஐஒ-கஙசஜஞடணதந-பம-ஹௐఅ-ఌఎ-ఐఒ-నప-ళవ-హఽౘౙౠౡಅ-ಌಎ-ಐಒ-ನಪ-ಳವ-ಹಽೞೠೡೱೲഅ-ഌഎ-ഐഒ-ഺഽൎൠൡൺ-ൿඅ-ඖක-නඳ-රලව-ෆก-ะาำเ-ๆກຂຄງຈຊຍດ-ທນ-ຟມ-ຣລວສຫອ-ະາຳຽເ-ໄໆໜ-ໟༀཀ-ཇཉ-ཬྈ-ྌက-ဪဿၐ-ၕၚ-ၝၡၥၦၮ-ၰၵ-ႁႎႠ-ჅჇჍა-ჺჼ-ቈቊ-ቍቐ-ቖቘቚ-ቝበ-ኈኊ-ኍነ-ኰኲ-ኵኸ-ኾዀዂ-ዅወ-ዖዘ-ጐጒ-ጕጘ-ፚᎀ-ᎏᎠ-Ᏼᐁ-ᙬᙯ-ᙿᚁ-ᚚᚠ-ᛪᛮ-ᛰᜀ-ᜌᜎ-ᜑᜠ-ᜱᝀ-ᝑᝠ-ᝬᝮ-ᝰក-ឳៗៜᠠ-ᡷᢀ-ᢨᢪᢰ-ᣵᤀ-ᤜᥐ-ᥭᥰ-ᥴᦀ-ᦫᧁ-ᧇᨀ-ᨖᨠ-ᩔᪧᬅ-ᬳᭅ-ᭋᮃ-ᮠᮮᮯᮺ-ᯥᰀ-ᰣᱍ-ᱏᱚ-ᱽᳩ-ᳬᳮ-ᳱᳵᳶᴀ-ᶿḀ-ἕἘ-Ἕἠ-ὅὈ-Ὅὐ-ὗὙὛὝὟ-ώᾀ-ᾴᾶ-ᾼιῂ-ῄῆ-ῌῐ-ΐῖ-Ίῠ-Ῥῲ-ῴῶ-ῼⁱⁿₐ-ₜℂℇℊ-ℓℕℙ-ℝℤΩℨK-ℭℯ-ℹℼ-ℿⅅ-ⅉⅎⅠ-ↈⰀ-Ⱞⰰ-ⱞⱠ-ⳤⳫ-ⳮⳲⳳⴀ-ⴥⴧⴭⴰ-ⵧⵯⶀ-ⶖⶠ-ⶦⶨ-ⶮⶰ-ⶶⶸ-ⶾⷀ-ⷆⷈ-ⷎⷐ-ⷖⷘ-ⷞⸯ々-〇〡-〩〱-〵〸-〼ぁ-ゖゝ-ゟァ-ヺー-ヿㄅ-ㄭㄱ-ㆎㆠ-ㆺㇰ-ㇿ㐀-䶵一-鿌ꀀ-ꒌꓐ-ꓽꔀ-ꘌꘐ-ꘟꘪꘫꙀ-ꙮꙿ-ꚗꚠ-ꛯꜗ-ꜟꜢ-ꞈꞋ-ꞎꞐ-ꞓꞠ-Ɦꟸ-ꠁꠃ-ꠅꠇ-ꠊꠌ-ꠢꡀ-ꡳꢂ-ꢳꣲ-ꣷꣻꤊ-ꤥꤰ-ꥆꥠ-ꥼꦄ-ꦲꧏꨀ-ꨨꩀ-ꩂꩄ-ꩋꩠ-ꩶꩺꪀ-ꪯꪱꪵꪶꪹ-ꪽꫀꫂꫛ-ꫝꫠ-ꫪꫲ-ꫴꬁ-ꬆꬉ-ꬎꬑ-ꬖꬠ-ꬦꬨ-ꬮꯀ-ꯢ가-힣ힰ-ퟆퟋ-ퟻ豈-舘並-龎ff-stﬓ-ﬗיִײַ-ﬨשׁ-זּטּ-לּמּנּסּףּפּצּ-ﮱﯓ-ﴽﵐ-ﶏﶒ-ﷇﷰ-ﷻﹰ-ﹴﹶ-ﻼＡ-Ｚａ-ｚｦ-ﾾￂ-ￇￊ-ￏￒ-ￗￚ-ￜ]"),
+          NonAsciiIdentifierPart: new RegExp("[ªµºÀ-ÖØ-öø-ˁˆ-ˑˠ-ˤˬˮ̀-ʹͶͷͺ-ͽΆΈ-ΊΌΎ-ΡΣ-ϵϷ-ҁ҃-҇Ҋ-ԧԱ-Ֆՙա-և֑-ׇֽֿׁׂׅׄא-תװ-ײؐ-ؚؠ-٩ٮ-ۓە-ۜ۟-۪ۨ-ۼۿܐ-݊ݍ-ޱ߀-ߵߺࠀ-࠭ࡀ-࡛ࢠࢢ-ࢬࣤ-ࣾऀ-ॣ०-९ॱ-ॷॹ-ॿঁ-ঃঅ-ঌএঐও-নপ-রলশ-হ়-ৄেৈো-ৎৗড়ঢ়য়-ৣ০-ৱਁ-ਃਅ-ਊਏਐਓ-ਨਪ-ਰਲਲ਼ਵਸ਼ਸਹ਼ਾ-ੂੇੈੋ-੍ੑਖ਼-ੜਫ਼੦-ੵઁ-ઃઅ-ઍએ-ઑઓ-નપ-રલળવ-હ઼-ૅે-ૉો-્ૐૠ-ૣ૦-૯ଁ-ଃଅ-ଌଏଐଓ-ନପ-ରଲଳଵ-ହ଼-ୄେୈୋ-୍ୖୗଡ଼ଢ଼ୟ-ୣ୦-୯ୱஂஃஅ-ஊஎ-ஐஒ-கஙசஜஞடணதந-பம-ஹா-ூெ-ைொ-்ௐௗ௦-௯ఁ-ఃఅ-ఌఎ-ఐఒ-నప-ళవ-హఽ-ౄె-ైొ-్ౕౖౘౙౠ-ౣ౦-౯ಂಃಅ-ಌಎ-ಐಒ-ನಪ-ಳವ-ಹ಼-ೄೆ-ೈೊ-್ೕೖೞೠ-ೣ೦-೯ೱೲംഃഅ-ഌഎ-ഐഒ-ഺഽ-ൄെ-ൈൊ-ൎൗൠ-ൣ൦-൯ൺ-ൿංඃඅ-ඖක-නඳ-රලව-ෆ්ා-ුූෘ-ෟෲෳก-ฺเ-๎๐-๙ກຂຄງຈຊຍດ-ທນ-ຟມ-ຣລວສຫອ-ູົ-ຽເ-ໄໆ່-ໍ໐-໙ໜ-ໟༀ༘༙༠-༩༹༵༷༾-ཇཉ-ཬཱ-྄྆-ྗྙ-ྼ࿆က-၉ၐ-ႝႠ-ჅჇჍა-ჺჼ-ቈቊ-ቍቐ-ቖቘቚ-ቝበ-ኈኊ-ኍነ-ኰኲ-ኵኸ-ኾዀዂ-ዅወ-ዖዘ-ጐጒ-ጕጘ-ፚ፝-፟ᎀ-ᎏᎠ-Ᏼᐁ-ᙬᙯ-ᙿᚁ-ᚚᚠ-ᛪᛮ-ᛰᜀ-ᜌᜎ-᜔ᜠ-᜴ᝀ-ᝓᝠ-ᝬᝮ-ᝰᝲᝳក-៓ៗៜ៝០-៩᠋-᠍᠐-᠙ᠠ-ᡷᢀ-ᢪᢰ-ᣵᤀ-ᤜᤠ-ᤫᤰ-᤻᥆-ᥭᥰ-ᥴᦀ-ᦫᦰ-ᧉ᧐-᧙ᨀ-ᨛᨠ-ᩞ᩠-᩿᩼-᪉᪐-᪙ᪧᬀ-ᭋ᭐-᭙᭫-᭳ᮀ-᯳ᰀ-᰷᱀-᱉ᱍ-ᱽ᳐-᳔᳒-ᳶᴀ-ᷦ᷼-ἕἘ-Ἕἠ-ὅὈ-Ὅὐ-ὗὙὛὝὟ-ώᾀ-ᾴᾶ-ᾼιῂ-ῄῆ-ῌῐ-ΐῖ-Ίῠ-Ῥῲ-ῴῶ-ῼ‌‍‿⁀⁔ⁱⁿₐ-ₜ⃐-⃥⃜⃡-⃰ℂℇℊ-ℓℕℙ-ℝℤΩℨK-ℭℯ-ℹℼ-ℿⅅ-ⅉⅎⅠ-ↈⰀ-Ⱞⰰ-ⱞⱠ-ⳤⳫ-ⳳⴀ-ⴥⴧⴭⴰ-ⵧⵯ⵿-ⶖⶠ-ⶦⶨ-ⶮⶰ-ⶶⶸ-ⶾⷀ-ⷆⷈ-ⷎⷐ-ⷖⷘ-ⷞⷠ-ⷿⸯ々-〇〡-〯〱-〵〸-〼ぁ-ゖ゙゚ゝ-ゟァ-ヺー-ヿㄅ-ㄭㄱ-ㆎㆠ-ㆺㇰ-ㇿ㐀-䶵一-鿌ꀀ-ꒌꓐ-ꓽꔀ-ꘌꘐ-ꘫꙀ-꙯ꙴ-꙽ꙿ-ꚗꚟ-꛱ꜗ-ꜟꜢ-ꞈꞋ-ꞎꞐ-ꞓꞠ-Ɦꟸ-ꠧꡀ-ꡳꢀ-꣄꣐-꣙꣠-ꣷꣻ꤀-꤭ꤰ-꥓ꥠ-ꥼꦀ-꧀ꧏ-꧙ꨀ-ꨶꩀ-ꩍ꩐-꩙ꩠ-ꩶꩺꩻꪀ-ꫂꫛ-ꫝꫠ-ꫯꫲ-꫶ꬁ-ꬆꬉ-ꬎꬑ-ꬖꬠ-ꬦꬨ-ꬮꯀ-ꯪ꯬꯭꯰-꯹가-힣ힰ-ퟆퟋ-ퟻ豈-舘並-龎ff-stﬓ-ﬗיִ-ﬨשׁ-זּטּ-לּמּנּסּףּפּצּ-ﮱﯓ-ﴽﵐ-ﶏﶒ-ﷇﷰ-ﷻ︀-️︠-︦︳︴﹍-﹏ﹰ-ﹴﹶ-ﻼ０-９Ａ-Ｚ＿ａ-ｚｦ-ﾾￂ-ￇￊ-ￏￒ-ￗￚ-ￜ]")
+        };
+        function I(e, t) {
+          if (!e)
+            throw new Error("ASSERT: " + t);
+        }
+        function M(e) {
+          return e >= 48 && e <= 57;
+        }
+        function z(e) {
+          return "0123456789abcdefABCDEF".indexOf(e) >= 0;
+        }
+        function T(e) {
+          return "01234567".indexOf(e) >= 0;
+        }
+        function N(e) {
+          return e === 32 || e === 9 || e === 11 || e === 12 || e === 160 || e >= 5760 && [5760, 6158, 8192, 8193, 8194, 8195, 8196, 8197, 8198, 8199, 8200, 8201, 8202, 8239, 8287, 12288, 65279].indexOf(e) >= 0;
+        }
+        function U(e) {
+          return e === 10 || e === 13 || e === 8232 || e === 8233;
+        }
+        function q(e) {
+          return e == 64 || e === 36 || e === 95 || e >= 65 && e <= 90 || e >= 97 && e <= 122 || e === 92 || e >= 128 && y.NonAsciiIdentifierStart.test(String.fromCharCode(e));
+        }
+        function V(e) {
+          return e === 36 || e === 95 || e >= 65 && e <= 90 || e >= 97 && e <= 122 || e >= 48 && e <= 57 || e === 92 || e >= 128 && y.NonAsciiIdentifierPart.test(String.fromCharCode(e));
+        }
+        function fe(e) {
+          switch (e) {
+            case "class":
+            case "enum":
+            case "export":
+            case "extends":
+            case "import":
+            case "super":
+              return !0;
+            default:
+              return !1;
+          }
+        }
+        function re(e) {
+          switch (e) {
+            case "implements":
+            case "interface":
+            case "package":
+            case "private":
+            case "protected":
+            case "public":
+            case "static":
+            case "yield":
+            case "let":
+              return !0;
+            default:
+              return !1;
+          }
+        }
+        function ee(e) {
+          return e === "eval" || e === "arguments";
+        }
+        function pe(e) {
+          if (E && re(e))
+            return !0;
+          switch (e.length) {
+            case 2:
+              return e === "if" || e === "in" || e === "do";
+            case 3:
+              return e === "var" || e === "for" || e === "new" || e === "try" || e === "let";
+            case 4:
+              return e === "this" || e === "else" || e === "case" || e === "void" || e === "with" || e === "enum";
+            case 5:
+              return e === "while" || e === "break" || e === "catch" || e === "throw" || e === "const" || e === "yield" || e === "class" || e === "super";
+            case 6:
+              return e === "return" || e === "typeof" || e === "delete" || e === "switch" || e === "export" || e === "import";
+            case 7:
+              return e === "default" || e === "finally" || e === "extends";
+            case 8:
+              return e === "function" || e === "continue" || e === "debugger";
+            case 10:
+              return e === "instanceof";
+            default:
+              return !1;
+          }
+        }
+        function ce(e, t, l, A, k) {
+          var O;
+          I(typeof l == "number", "Comment must have valid position"), !(b.lastCommentStart >= l) && (b.lastCommentStart = l, O = {
+            type: e,
+            value: t
+          }, g.range && (O.range = [l, A]), g.loc && (O.loc = k), g.comments.push(O), g.attachComment && (g.leadingComments.push(O), g.trailingComments.push(O)));
+        }
+        function he(e) {
+          var t, l, A, k;
+          for (t = u - e, l = {
+            start: {
+              line: S,
+              column: u - B - e
+            }
+          }; u < D; )
+            if (A = d.charCodeAt(u), ++u, U(A)) {
+              g.comments && (k = d.slice(t + e, u - 1), l.end = {
+                line: S,
+                column: u - B - 1
+              }, ce("Line", k, t, u - 1, l)), A === 13 && d.charCodeAt(u) === 10 && ++u, ++S, B = u;
+              return;
+            }
+          g.comments && (k = d.slice(t + e, u), l.end = {
+            line: S,
+            column: u - B
+          }, ce("Line", k, t, u, l));
+        }
+        function Ne() {
+          var e, t, l, A;
+          for (g.comments && (e = u - 2, t = {
+            start: {
+              line: S,
+              column: u - B - 2
+            }
+          }); u < D; )
+            if (l = d.charCodeAt(u), U(l))
+              l === 13 && d.charCodeAt(u + 1) === 10 && ++u, ++S, ++u, B = u, u >= D && $({}, p.UnexpectedToken, "ILLEGAL");
+            else if (l === 42) {
+              if (d.charCodeAt(u + 1) === 47) {
+                ++u, ++u, g.comments && (A = d.slice(e + 2, u - 2), t.end = {
+                  line: S,
+                  column: u - B
+                }, ce("Block", A, e, u, t));
+                return;
+              }
+              ++u;
+            } else
+              ++u;
+          $({}, p.UnexpectedToken, "ILLEGAL");
+        }
+        function _() {
+          var e, t;
+          for (t = u === 0; u < D; )
+            if (e = d.charCodeAt(u), N(e))
+              ++u;
+            else if (U(e))
+              ++u, e === 13 && d.charCodeAt(u) === 10 && ++u, ++S, B = u, t = !0;
+            else if (e === 47)
+              if (e = d.charCodeAt(u + 1), e === 47)
+                ++u, ++u, he(2), t = !0;
+              else if (e === 42)
+                ++u, ++u, Ne();
+              else
+                break;
+            else if (t && e === 45)
+              if (d.charCodeAt(u + 1) === 45 && d.charCodeAt(u + 2) === 62)
+                u += 3, he(3);
+              else
+                break;
+            else if (e === 60)
+              if (d.slice(u + 1, u + 4) === "!--")
+                ++u, ++u, ++u, ++u, he(4);
+              else
+                break;
+            else
+              break;
+        }
+        function w(e) {
+          var t, l, A, k = 0;
+          for (l = e === "u" ? 4 : 2, t = 0; t < l; ++t)
+            if (u < D && z(d[u]))
+              A = d[u++], k = k * 16 + "0123456789abcdef".indexOf(A.toLowerCase());
+            else
+              return "";
+          return String.fromCharCode(k);
+        }
+        function P() {
+          var e, t;
+          for (e = d.charCodeAt(u++), t = String.fromCharCode(e), e === 92 && (d.charCodeAt(u) !== 117 && $({}, p.UnexpectedToken, "ILLEGAL"), ++u, e = w("u"), (!e || e === "\\" || !q(e.charCodeAt(0))) && $({}, p.UnexpectedToken, "ILLEGAL"), t = e); u < D && (e = d.charCodeAt(u), !!V(e)); )
+            ++u, t += String.fromCharCode(e), e === 92 && (t = t.substr(0, t.length - 1), d.charCodeAt(u) !== 117 && $({}, p.UnexpectedToken, "ILLEGAL"), ++u, e = w("u"), (!e || e === "\\" || !V(e.charCodeAt(0))) && $({}, p.UnexpectedToken, "ILLEGAL"), t += e);
+          return t;
+        }
+        function Q() {
+          var e, t;
+          for (e = u++; u < D; ) {
+            if (t = d.charCodeAt(u), t === 92)
+              return u = e, P();
+            if (V(t))
+              ++u;
+            else
+              break;
+          }
+          return d.slice(e, u);
+        }
+        function ie() {
+          var e, t, l;
+          return e = u, t = d.charCodeAt(u) === 92 ? P() : Q(), t.length === 1 ? l = c.Identifier : pe(t) ? l = c.Keyword : t === "null" ? l = c.NullLiteral : t === "true" || t === "false" ? l = c.BooleanLiteral : l = c.Identifier, {
+            type: l,
+            value: t,
+            lineNumber: S,
+            lineStart: B,
+            start: e,
+            end: u
+          };
+        }
+        function G() {
+          var e = u, t = d.charCodeAt(u), l, A = d[u], k, O, H;
+          switch (t) {
+            case 46:
+            case 40:
+            case 41:
+            case 59:
+            case 44:
+            case 123:
+            case 125:
+            case 91:
+            case 93:
+            case 58:
+            case 63:
+            case 126:
+              return ++u, g.tokenize && (t === 40 ? g.openParenToken = g.tokens.length : t === 123 && (g.openCurlyToken = g.tokens.length)), {
+                type: c.Punctuator,
+                value: String.fromCharCode(t),
+                lineNumber: S,
+                lineStart: B,
+                start: e,
+                end: u
+              };
+            default:
+              if (l = d.charCodeAt(u + 1), l === 61)
+                switch (t) {
+                  case 43:
+                  case 45:
+                  case 47:
+                  case 60:
+                  case 62:
+                  case 94:
+                  case 124:
+                  case 37:
+                  case 38:
+                  case 42:
+                    return u += 2, {
+                      type: c.Punctuator,
+                      value: String.fromCharCode(t) + String.fromCharCode(l),
+                      lineNumber: S,
+                      lineStart: B,
+                      start: e,
+                      end: u
+                    };
+                  case 33:
+                  case 61:
+                    return u += 2, d.charCodeAt(u) === 61 && ++u, {
+                      type: c.Punctuator,
+                      value: d.slice(e, u),
+                      lineNumber: S,
+                      lineStart: B,
+                      start: e,
+                      end: u
+                    };
+                }
+          }
+          if (H = d.substr(u, 4), H === ">>>=")
+            return u += 4, {
+              type: c.Punctuator,
+              value: H,
+              lineNumber: S,
+              lineStart: B,
+              start: e,
+              end: u
+            };
+          if (O = H.substr(0, 3), O === ">>>" || O === "<<=" || O === ">>=")
+            return u += 3, {
+              type: c.Punctuator,
+              value: O,
+              lineNumber: S,
+              lineStart: B,
+              start: e,
+              end: u
+            };
+          if (k = O.substr(0, 2), A === k[1] && "+-<>&|".indexOf(A) >= 0 || k === "=>")
+            return u += 2, {
+              type: c.Punctuator,
+              value: k,
+              lineNumber: S,
+              lineStart: B,
+              start: e,
+              end: u
+            };
+          if ("<>=!+-*%&|^/".indexOf(A) >= 0)
+            return ++u, {
+              type: c.Punctuator,
+              value: A,
+              lineNumber: S,
+              lineStart: B,
+              start: e,
+              end: u
+            };
+          $({}, p.UnexpectedToken, "ILLEGAL");
+        }
+        function K(e) {
+          for (var t = ""; u < D && z(d[u]); )
+            t += d[u++];
+          return t.length === 0 && $({}, p.UnexpectedToken, "ILLEGAL"), q(d.charCodeAt(u)) && $({}, p.UnexpectedToken, "ILLEGAL"), {
+            type: c.NumericLiteral,
+            value: parseInt("0x" + t, 16),
+            lineNumber: S,
+            lineStart: B,
+            start: e,
+            end: u
+          };
+        }
+        function Z(e) {
+          for (var t = "0" + d[u++]; u < D && T(d[u]); )
+            t += d[u++];
+          return (q(d.charCodeAt(u)) || M(d.charCodeAt(u))) && $({}, p.UnexpectedToken, "ILLEGAL"), {
+            type: c.NumericLiteral,
+            value: parseInt(t, 8),
+            octal: !0,
+            lineNumber: S,
+            lineStart: B,
+            start: e,
+            end: u
+          };
+        }
+        function te() {
+          var e, t, l;
+          if (l = d[u], I(
+            M(l.charCodeAt(0)) || l === ".",
+            "Numeric literal must start with a decimal digit or a decimal point"
+          ), t = u, e = "", l !== ".") {
+            if (e = d[u++], l = d[u], e === "0") {
+              if (l === "x" || l === "X")
+                return ++u, K(t);
+              if (T(l))
+                return Z(t);
+              l && M(l.charCodeAt(0)) && $({}, p.UnexpectedToken, "ILLEGAL");
+            }
+            for (; M(d.charCodeAt(u)); )
+              e += d[u++];
+            l = d[u];
+          }
+          if (l === ".") {
+            for (e += d[u++]; M(d.charCodeAt(u)); )
+              e += d[u++];
+            l = d[u];
+          }
+          if (l === "e" || l === "E")
+            if (e += d[u++], l = d[u], (l === "+" || l === "-") && (e += d[u++]), M(d.charCodeAt(u)))
+              for (; M(d.charCodeAt(u)); )
+                e += d[u++];
+            else
+              $({}, p.UnexpectedToken, "ILLEGAL");
+          return q(d.charCodeAt(u)) && $({}, p.UnexpectedToken, "ILLEGAL"), {
+            type: c.NumericLiteral,
+            value: parseFloat(e),
+            lineNumber: S,
+            lineStart: B,
+            start: t,
+            end: u
+          };
+        }
+        function Ee() {
+          var e = "", t, l, A, k, O, H, J = !1, oe, ae;
+          for (oe = S, ae = B, t = d[u], I(
+            t === "'" || t === '"',
+            "String literal must starts with a quote"
+          ), l = u, ++u; u < D; )
+            if (A = d[u++], A === t) {
+              t = "";
+              break;
+            } else if (A === "\\")
+              if (A = d[u++], !A || !U(A.charCodeAt(0)))
+                switch (A) {
+                  case "u":
+                  case "x":
+                    H = u, O = w(A), O ? e += O : (u = H, e += A);
+                    break;
+                  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:
+                    T(A) ? (k = "01234567".indexOf(A), k !== 0 && (J = !0), u < D && T(d[u]) && (J = !0, k = k * 8 + "01234567".indexOf(d[u++]), "0123".indexOf(A) >= 0 && u < D && T(d[u]) && (k = k * 8 + "01234567".indexOf(d[u++]))), e += String.fromCharCode(k)) : e += A;
+                    break;
+                }
+              else
+                ++S, A === "\r" && d[u] === `
+` && ++u, B = u;
+            else {
+              if (U(A.charCodeAt(0)))
+                break;
+              e += A;
+            }
+          return t !== "" && $({}, p.UnexpectedToken, "ILLEGAL"), {
+            type: c.StringLiteral,
+            value: e,
+            octal: J,
+            startLineNumber: oe,
+            startLineStart: ae,
+            lineNumber: S,
+            lineStart: B,
+            start: l,
+            end: u
+          };
+        }
+        function De(e, t) {
+          var l;
+          try {
+            l = new RegExp(e, t);
+          } catch {
+            $({}, p.InvalidRegExp);
+          }
+          return l;
+        }
+        function $e() {
+          var e, t, l, A, k;
+          for (e = d[u], I(e === "/", "Regular expression literal must start with a slash"), t = d[u++], l = !1, A = !1; u < D; )
+            if (e = d[u++], t += e, e === "\\")
+              e = d[u++], U(e.charCodeAt(0)) && $({}, p.UnterminatedRegExp), t += e;
+            else if (U(e.charCodeAt(0)))
+              $({}, p.UnterminatedRegExp);
+            else if (l)
+              e === "]" && (l = !1);
+            else if (e === "/") {
+              A = !0;
+              break;
+            } else
+              e === "[" && (l = !0);
+          return A || $({}, p.UnterminatedRegExp), k = t.substr(1, t.length - 2), {
+            value: k,
+            literal: t
+          };
+        }
+        function we() {
+          var e, t, l, A;
+          for (t = "", l = ""; u < D && (e = d[u], !!V(e.charCodeAt(0))); )
+            if (++u, e === "\\" && u < D)
+              if (e = d[u], e === "u") {
+                if (++u, A = u, e = w("u"), e)
+                  for (l += e, t += "\\u"; A < u; ++A)
+                    t += d[A];
+                else
+                  u = A, l += "u", t += "\\u";
+                W({}, p.UnexpectedToken, "ILLEGAL");
+              } else
+                t += "\\", W({}, p.UnexpectedToken, "ILLEGAL");
+            else
+              l += e, t += e;
+          return {
+            value: l,
+            literal: t
+          };
+        }
+        function Re() {
+          var e, t, l, A;
+          return f = null, _(), e = u, t = $e(), l = we(), A = De(t.value, l.value), g.tokenize ? {
+            type: c.RegularExpression,
+            value: A,
+            lineNumber: S,
+            lineStart: B,
+            start: e,
+            end: u
+          } : {
+            literal: t.literal + l.literal,
+            value: A,
+            start: e,
+            end: u
+          };
+        }
+        function Ce() {
+          var e, t, l, A;
+          return _(), e = u, t = {
+            start: {
+              line: S,
+              column: u - B
+            }
+          }, l = Re(), t.end = {
+            line: S,
+            column: u - B
+          }, g.tokenize || (g.tokens.length > 0 && (A = g.tokens[g.tokens.length - 1], A.range[0] === e && A.type === "Punctuator" && (A.value === "/" || A.value === "/=") && g.tokens.pop()), g.tokens.push({
+            type: "RegularExpression",
+            value: l.literal,
+            range: [e, u],
+            loc: t
+          })), l;
+        }
+        function At(e) {
+          return e.type === c.Identifier || e.type === c.Keyword || e.type === c.BooleanLiteral || e.type === c.NullLiteral;
+        }
+        function vt() {
+          var e, t;
+          if (e = g.tokens[g.tokens.length - 1], !e)
+            return Ce();
+          if (e.type === "Punctuator") {
+            if (e.value === "]")
+              return G();
+            if (e.value === ")")
+              return t = g.tokens[g.openParenToken - 1], t && t.type === "Keyword" && (t.value === "if" || t.value === "while" || t.value === "for" || t.value === "with") ? Ce() : G();
+            if (e.value === "}") {
+              if (g.tokens[g.openCurlyToken - 3] && g.tokens[g.openCurlyToken - 3].type === "Keyword") {
+                if (t = g.tokens[g.openCurlyToken - 4], !t)
+                  return G();
+              } else if (g.tokens[g.openCurlyToken - 4] && g.tokens[g.openCurlyToken - 4].type === "Keyword") {
+                if (t = g.tokens[g.openCurlyToken - 5], !t)
+                  return Ce();
+              } else
+                return G();
+              return v.indexOf(t.value) >= 0 ? G() : Ce();
+            }
+            return Ce();
+          }
+          return e.type === "Keyword" ? Ce() : G();
+        }
+        function He() {
+          var e;
+          return _(), u >= D ? {
+            type: c.EOF,
+            lineNumber: S,
+            lineStart: B,
+            start: u,
+            end: u
+          } : (e = d.charCodeAt(u), q(e) ? ie() : e === 40 || e === 41 || e === 59 ? G() : e === 39 || e === 34 ? Ee() : e === 46 ? M(d.charCodeAt(u + 1)) ? te() : G() : M(e) ? te() : g.tokenize && e === 47 ? vt() : G());
+        }
+        function et() {
+          var e, t, l;
+          return _(), e = {
+            start: {
+              line: S,
+              column: u - B
+            }
+          }, t = He(), e.end = {
+            line: S,
+            column: u - B
+          }, t.type !== c.EOF && (l = d.slice(t.start, t.end), g.tokens.push({
+            type: x[t.type],
+            value: l,
+            range: [t.start, t.end],
+            loc: e
+          })), t;
+        }
+        function j() {
+          var e;
+          return e = f, u = e.end, S = e.lineNumber, B = e.lineStart, f = typeof g.tokens < "u" ? et() : He(), u = e.end, S = e.lineNumber, B = e.lineStart, e;
+        }
+        function ze() {
+          var e, t, l;
+          e = u, t = S, l = B, f = typeof g.tokens < "u" ? et() : He(), u = e, S = t, B = l;
+        }
+        function tt(e, t) {
+          this.line = e, this.column = t;
+        }
+        function bt(e, t, l, A) {
+          this.start = new tt(e, t), this.end = new tt(l, A);
+        }
+        F = {
+          name: "SyntaxTree",
+          processComment: function(e) {
+            var t, l;
+            if (!(e.type === C.Program && e.body.length > 0)) {
+              for (g.trailingComments.length > 0 ? g.trailingComments[0].range[0] >= e.range[1] ? (l = g.trailingComments, g.trailingComments = []) : g.trailingComments.length = 0 : g.bottomRightStack.length > 0 && g.bottomRightStack[g.bottomRightStack.length - 1].trailingComments && g.bottomRightStack[g.bottomRightStack.length - 1].trailingComments[0].range[0] >= e.range[1] && (l = g.bottomRightStack[g.bottomRightStack.length - 1].trailingComments, delete g.bottomRightStack[g.bottomRightStack.length - 1].trailingComments); g.bottomRightStack.length > 0 && g.bottomRightStack[g.bottomRightStack.length - 1].range[0] >= e.range[0]; )
+                t = g.bottomRightStack.pop();
+              t ? t.leadingComments && t.leadingComments[t.leadingComments.length - 1].range[1] <= e.range[0] && (e.leadingComments = t.leadingComments, delete t.leadingComments) : g.leadingComments.length > 0 && g.leadingComments[g.leadingComments.length - 1].range[1] <= e.range[0] && (e.leadingComments = g.leadingComments, g.leadingComments = []), l && (e.trailingComments = l), g.bottomRightStack.push(e);
+            }
+          },
+          markEnd: function(e, t) {
+            return g.range && (e.range = [t.start, u]), g.loc && (e.loc = new bt(
+              t.startLineNumber === void 0 ? t.lineNumber : t.startLineNumber,
+              t.start - (t.startLineStart === void 0 ? t.lineStart : t.startLineStart),
+              S,
+              u - B
+            ), this.postProcess(e)), g.attachComment && this.processComment(e), e;
+          },
+          postProcess: function(e) {
+            return g.source && (e.loc.source = g.source), e;
+          },
+          createArrayExpression: function(e) {
+            return {
+              type: C.ArrayExpression,
+              elements: e
+            };
+          },
+          createAssignmentExpression: function(e, t, l) {
+            return {
+              type: C.AssignmentExpression,
+              operator: e,
+              left: t,
+              right: l
+            };
+          },
+          createBinaryExpression: function(e, t, l) {
+            var A = e === "||" || e === "&&" ? C.LogicalExpression : C.BinaryExpression;
+            return {
+              type: A,
+              operator: e,
+              left: t,
+              right: l
+            };
+          },
+          createBlockStatement: function(e) {
+            return {
+              type: C.BlockStatement,
+              body: e
+            };
+          },
+          createBreakStatement: function(e) {
+            return {
+              type: C.BreakStatement,
+              label: e
+            };
+          },
+          createCallExpression: function(e, t) {
+            return {
+              type: C.CallExpression,
+              callee: e,
+              arguments: t
+            };
+          },
+          createCatchClause: function(e, t) {
+            return {
+              type: C.CatchClause,
+              param: e,
+              body: t
+            };
+          },
+          createConditionalExpression: function(e, t, l) {
+            return {
+              type: C.ConditionalExpression,
+              test: e,
+              consequent: t,
+              alternate: l
+            };
+          },
+          createContinueStatement: function(e) {
+            return {
+              type: C.ContinueStatement,
+              label: e
+            };
+          },
+          createDebuggerStatement: function() {
+            return {
+              type: C.DebuggerStatement
+            };
+          },
+          createDoWhileStatement: function(e, t) {
+            return {
+              type: C.DoWhileStatement,
+              body: e,
+              test: t
+            };
+          },
+          createEmptyStatement: function() {
+            return {
+              type: C.EmptyStatement
+            };
+          },
+          createExpressionStatement: function(e) {
+            return {
+              type: C.ExpressionStatement,
+              expression: e
+            };
+          },
+          createForStatement: function(e, t, l, A) {
+            return {
+              type: C.ForStatement,
+              init: e,
+              test: t,
+              update: l,
+              body: A
+            };
+          },
+          createForInStatement: function(e, t, l) {
+            return {
+              type: C.ForInStatement,
+              left: e,
+              right: t,
+              body: l,
+              each: !1
+            };
+          },
+          createFunctionDeclaration: function(e, t, l, A) {
+            return {
+              type: C.FunctionDeclaration,
+              id: e,
+              params: t,
+              defaults: l,
+              body: A,
+              rest: null,
+              generator: !1,
+              expression: !1
+            };
+          },
+          createFunctionExpression: function(e, t, l, A) {
+            return {
+              type: C.FunctionExpression,
+              id: e,
+              params: t,
+              defaults: l,
+              body: A,
+              rest: null,
+              generator: !1,
+              expression: !1
+            };
+          },
+          createIdentifier: function(e) {
+            return {
+              type: C.Identifier,
+              name: e
+            };
+          },
+          createIfStatement: function(e, t, l) {
+            return {
+              type: C.IfStatement,
+              test: e,
+              consequent: t,
+              alternate: l
+            };
+          },
+          createLabeledStatement: function(e, t) {
+            return {
+              type: C.LabeledStatement,
+              label: e,
+              body: t
+            };
+          },
+          createLiteral: function(e) {
+            return {
+              type: C.Literal,
+              value: e.value,
+              raw: d.slice(e.start, e.end)
+            };
+          },
+          createMemberExpression: function(e, t, l) {
+            return {
+              type: C.MemberExpression,
+              computed: e === "[",
+              object: t,
+              property: l
+            };
+          },
+          createNewExpression: function(e, t) {
+            return {
+              type: C.NewExpression,
+              callee: e,
+              arguments: t
+            };
+          },
+          createObjectExpression: function(e) {
+            return {
+              type: C.ObjectExpression,
+              properties: e
+            };
+          },
+          createPostfixExpression: function(e, t) {
+            return {
+              type: C.UpdateExpression,
+              operator: e,
+              argument: t,
+              prefix: !1
+            };
+          },
+          createProgram: function(e) {
+            return {
+              type: C.Program,
+              body: e
+            };
+          },
+          createProperty: function(e, t, l) {
+            return {
+              type: C.Property,
+              key: t,
+              value: l,
+              kind: e
+            };
+          },
+          createReturnStatement: function(e) {
+            return {
+              type: C.ReturnStatement,
+              argument: e
+            };
+          },
+          createSequenceExpression: function(e) {
+            return {
+              type: C.SequenceExpression,
+              expressions: e
+            };
+          },
+          createSwitchCase: function(e, t) {
+            return {
+              type: C.SwitchCase,
+              test: e,
+              consequent: t
+            };
+          },
+          createSwitchStatement: function(e, t) {
+            return {
+              type: C.SwitchStatement,
+              discriminant: e,
+              cases: t
+            };
+          },
+          createThisExpression: function() {
+            return {
+              type: C.ThisExpression
+            };
+          },
+          createThrowStatement: function(e) {
+            return {
+              type: C.ThrowStatement,
+              argument: e
+            };
+          },
+          createTryStatement: function(e, t, l, A) {
+            return {
+              type: C.TryStatement,
+              block: e,
+              guardedHandlers: t,
+              handlers: l,
+              finalizer: A
+            };
+          },
+          createUnaryExpression: function(e, t) {
+            return e === "++" || e === "--" ? {
+              type: C.UpdateExpression,
+              operator: e,
+              argument: t,
+              prefix: !0
+            } : {
+              type: C.UnaryExpression,
+              operator: e,
+              argument: t,
+              prefix: !0
+            };
+          },
+          createVariableDeclaration: function(e, t) {
+            return {
+              type: C.VariableDeclaration,
+              declarations: e,
+              kind: t
+            };
+          },
+          createVariableDeclarator: function(e, t) {
+            return {
+              type: C.VariableDeclarator,
+              id: e,
+              init: t
+            };
+          },
+          createWhileStatement: function(e, t) {
+            return {
+              type: C.WhileStatement,
+              test: e,
+              body: t
+            };
+          },
+          createWithStatement: function(e, t) {
+            return {
+              type: C.WithStatement,
+              object: e,
+              body: t
+            };
+          }
+        };
+        function Oe() {
+          var e, t, l, A;
+          return e = u, t = S, l = B, _(), A = S !== t, u = e, S = t, B = l, A;
+        }
+        function $(e, t) {
+          var l, A = Array.prototype.slice.call(arguments, 2), k = t.replace(
+            /%(\d)/g,
+            function(O, H) {
+              return I(H < A.length, "Message reference must be in range"), A[H];
+            }
+          );
+          throw typeof e.lineNumber == "number" ? (l = new Error("Line " + e.lineNumber + ": " + k), l.index = e.start, l.lineNumber = e.lineNumber, l.column = e.start - B + 1) : (l = new Error("Line " + S + ": " + k), l.index = u, l.lineNumber = S, l.column = u - B + 1), l.description = k, l;
+        }
+        function W() {
+          try {
+            $.apply(null, arguments);
+          } catch (e) {
+            if (g.errors)
+              g.errors.push(e);
+            else
+              throw e;
+          }
+        }
+        function ge(e) {
+          if (e.type === c.EOF && $(e, p.UnexpectedEOS), e.type === c.NumericLiteral && $(e, p.UnexpectedNumber), e.type === c.StringLiteral && $(e, p.UnexpectedString), e.type === c.Identifier && $(e, p.UnexpectedIdentifier), e.type === c.Keyword) {
+            if (fe(e.value))
+              $(e, p.UnexpectedReserved);
+            else if (E && re(e.value)) {
+              W(e, p.StrictReservedWord);
+              return;
+            }
+            $(e, p.UnexpectedToken, e.value);
+          }
+          $(e, p.UnexpectedToken, e.value);
+        }
+        function L(e) {
+          var t = j();
+          (t.type !== c.Punctuator || t.value !== e) && ge(t);
+        }
+        function ne(e) {
+          var t = j();
+          (t.type !== c.Keyword || t.value !== e) && ge(t);
+        }
+        function R(e) {
+          return f.type === c.Punctuator && f.value === e;
+        }
+        function se(e) {
+          return f.type === c.Keyword && f.value === e;
+        }
+        function Ft() {
+          var e;
+          return f.type !== c.Punctuator ? !1 : (e = f.value, e === "=" || e === "*=" || e === "/=" || e === "%=" || e === "+=" || e === "-=" || e === "<<=" || e === ">>=" || e === ">>>=" || e === "&=" || e === "^=" || e === "|=");
+        }
+        function Ae() {
+          var e;
+          if (d.charCodeAt(u) === 59 || R(";")) {
+            j();
+            return;
+          }
+          e = S, _(), S === e && f.type !== c.EOF && !R("}") && ge(f);
+        }
+        function Le(e) {
+          return e.type === C.Identifier || e.type === C.MemberExpression;
+        }
+        function Ct() {
+          var e = [], t;
+          for (t = f, L("["); !R("]"); )
+            R(",") ? (j(), e.push(null)) : (e.push(me()), R("]") || L(","));
+          return j(), a.markEnd(a.createArrayExpression(e), t);
+        }
+        function qe(e, t) {
+          var l, A, k;
+          return l = E, k = f, A = Xe(), t && E && ee(e[0].name) && W(t, p.StrictParamName), E = l, a.markEnd(a.createFunctionExpression(null, e, [], A), k);
+        }
+        function Me() {
+          var e, t;
+          return t = f, e = j(), e.type === c.StringLiteral || e.type === c.NumericLiteral ? (E && e.octal && W(e, p.StrictOctalLiteral), a.markEnd(a.createLiteral(e), t)) : a.markEnd(a.createIdentifier(e.value), t);
+        }
+        function Dt() {
+          var e, t, l, A, k, O;
+          if (e = f, O = f, e.type === c.Identifier)
+            return l = Me(), e.value === "get" && !R(":") ? (t = Me(), L("("), L(")"), A = qe([]), a.markEnd(a.createProperty("get", t, A), O)) : e.value === "set" && !R(":") ? (t = Me(), L("("), e = f, e.type !== c.Identifier ? (L(")"), W(e, p.UnexpectedToken, e.value), A = qe([])) : (k = [be()], L(")"), A = qe(k, e)), a.markEnd(a.createProperty("set", t, A), O)) : (L(":"), A = me(), a.markEnd(a.createProperty("init", l, A), O));
+          if (e.type === c.EOF || e.type === c.Punctuator)
+            ge(e);
+          else
+            return t = Me(), L(":"), A = me(), a.markEnd(a.createProperty("init", t, A), O);
+        }
+        function xt() {
+          var e = [], t, l, A, k, O = {}, H = String, J;
+          for (J = f, L("{"); !R("}"); )
+            t = Dt(), t.key.type === C.Identifier ? l = t.key.name : l = H(t.key.value), k = t.kind === "init" ? m.Data : t.kind === "get" ? m.Get : m.Set, A = "$" + l, Object.prototype.hasOwnProperty.call(O, A) ? (O[A] === m.Data ? E && k === m.Data ? W({}, p.StrictDuplicateProperty) : k !== m.Data && W({}, p.AccessorDataProperty) : k === m.Data ? W({}, p.AccessorDataProperty) : O[A] & k && W({}, p.AccessorGetSet), O[A] |= k) : O[A] = k, e.push(t), R("}") || L(",");
+          return L("}"), a.markEnd(a.createObjectExpression(e), J);
+        }
+        function St() {
+          var e;
+          return L("("), e = ue(), L(")"), e;
+        }
+        function rt() {
+          var e, t, l, A;
+          if (R("("))
+            return St();
+          if (R("["))
+            return Ct();
+          if (R("{"))
+            return xt();
+          if (e = f.type, A = f, e === c.Identifier)
+            l = a.createIdentifier(j().value);
+          else if (e === c.StringLiteral || e === c.NumericLiteral)
+            E && f.octal && W(f, p.StrictOctalLiteral), l = a.createLiteral(j());
+          else if (e === c.Keyword) {
+            if (se("function"))
+              return Zt();
+            se("this") ? (j(), l = a.createThisExpression()) : ge(j());
+          } else
+            e === c.BooleanLiteral ? (t = j(), t.value = t.value === "true", l = a.createLiteral(t)) : e === c.NullLiteral ? (t = j(), t.value = null, l = a.createLiteral(t)) : R("/") || R("/=") ? (typeof g.tokens < "u" ? l = a.createLiteral(Ce()) : l = a.createLiteral(Re()), ze()) : ge(j());
+          return a.markEnd(l, A);
+        }
+        function nt() {
+          var e = [];
+          if (L("("), !R(")"))
+            for (; u < D && (e.push(me()), !R(")")); )
+              L(",");
+          return L(")"), e;
+        }
+        function _t() {
+          var e, t;
+          return t = f, e = j(), At(e) || ge(e), a.markEnd(a.createIdentifier(e.value), t);
+        }
+        function it() {
+          return L("."), _t();
+        }
+        function ut() {
+          var e;
+          return L("["), e = ue(), L("]"), e;
+        }
+        function at() {
+          var e, t, l;
+          return l = f, ne("new"), e = Bt(), t = R("(") ? nt() : [], a.markEnd(a.createNewExpression(e, t), l);
+        }
+        function kt() {
+          var e, t, l, A, k;
+          for (k = f, e = b.allowIn, b.allowIn = !0, t = se("new") ? at() : rt(), b.allowIn = e; ; ) {
+            if (R("."))
+              A = it(), t = a.createMemberExpression(".", t, A);
+            else if (R("("))
+              l = nt(), t = a.createCallExpression(t, l);
+            else if (R("["))
+              A = ut(), t = a.createMemberExpression("[", t, A);
+            else
+              break;
+            a.markEnd(t, k);
+          }
+          return t;
+        }
+        function Bt() {
+          var e, t, l, A;
+          for (A = f, e = b.allowIn, t = se("new") ? at() : rt(), b.allowIn = e; R(".") || R("["); )
+            R("[") ? (l = ut(), t = a.createMemberExpression("[", t, l)) : (l = it(), t = a.createMemberExpression(".", t, l)), a.markEnd(t, A);
+          return t;
+        }
+        function st() {
+          var e, t, l = f;
+          return e = kt(), f.type === c.Punctuator && (R("++") || R("--")) && !Oe() && (E && e.type === C.Identifier && ee(e.name) && W({}, p.StrictLHSPostfix), Le(e) || W({}, p.InvalidLHSInAssignment), t = j(), e = a.markEnd(a.createPostfixExpression(t.value, e), l)), e;
+        }
+        function xe() {
+          var e, t, l;
+          return f.type !== c.Punctuator && f.type !== c.Keyword ? t = st() : R("++") || R("--") ? (l = f, e = j(), t = xe(), E && t.type === C.Identifier && ee(t.name) && W({}, p.StrictLHSPrefix), Le(t) || W({}, p.InvalidLHSInAssignment), t = a.createUnaryExpression(e.value, t), t = a.markEnd(t, l)) : R("+") || R("-") || R("~") || R("!") ? (l = f, e = j(), t = xe(), t = a.createUnaryExpression(e.value, t), t = a.markEnd(t, l)) : se("delete") || se("void") || se("typeof") ? (l = f, e = j(), t = xe(), t = a.createUnaryExpression(e.value, t), t = a.markEnd(t, l), E && t.operator === "delete" && t.argument.type === C.Identifier && W({}, p.StrictDelete)) : t = st(), t;
+        }
+        function ot(e, t) {
+          var l = 0;
+          if (e.type !== c.Punctuator && e.type !== c.Keyword)
+            return 0;
+          switch (e.value) {
+            case "||":
+              l = 1;
+              break;
+            case "&&":
+              l = 2;
+              break;
+            case "|":
+              l = 3;
+              break;
+            case "^":
+              l = 4;
+              break;
+            case "&":
+              l = 5;
+              break;
+            case "==":
+            case "!=":
+            case "===":
+            case "!==":
+              l = 6;
+              break;
+            case "<":
+            case ">":
+            case "<=":
+            case ">=":
+            case "instanceof":
+              l = 7;
+              break;
+            case "in":
+              l = t ? 7 : 0;
+              break;
+            case "<<":
+            case ">>":
+            case ">>>":
+              l = 8;
+              break;
+            case "+":
+            case "-":
+              l = 9;
+              break;
+            case "*":
+            case "/":
+            case "%":
+              l = 11;
+              break;
+          }
+          return l;
+        }
+        function wt() {
+          var e, t, l, A, k, O, H, J, oe, ae;
+          if (e = f, oe = xe(), A = f, k = ot(A, b.allowIn), k === 0)
+            return oe;
+          for (A.prec = k, j(), t = [e, f], H = xe(), O = [oe, A, H]; (k = ot(f, b.allowIn)) > 0; ) {
+            for (; O.length > 2 && k <= O[O.length - 2].prec; )
+              H = O.pop(), J = O.pop().value, oe = O.pop(), l = a.createBinaryExpression(J, oe, H), t.pop(), e = t[t.length - 1], a.markEnd(l, e), O.push(l);
+            A = j(), A.prec = k, O.push(A), t.push(f), l = xe(), O.push(l);
+          }
+          for (ae = O.length - 1, l = O[ae], t.pop(); ae > 1; )
+            l = a.createBinaryExpression(O[ae - 1].value, O[ae - 2], l), ae -= 2, e = t.pop(), a.markEnd(l, e);
+          return l;
+        }
+        function Ot() {
+          var e, t, l, A, k;
+          return k = f, e = wt(), R("?") && (j(), t = b.allowIn, b.allowIn = !0, l = me(), b.allowIn = t, L(":"), A = me(), e = a.createConditionalExpression(e, l, A), a.markEnd(e, k)), e;
+        }
+        function me() {
+          var e, t, l, A, k;
+          return e = f, k = f, A = t = Ot(), Ft() && (Le(t) || W({}, p.InvalidLHSInAssignment), E && t.type === C.Identifier && ee(t.name) && W(e, p.StrictLHSAssignment), e = j(), l = me(), A = a.markEnd(a.createAssignmentExpression(e.value, t, l), k)), A;
+        }
+        function ue() {
+          var e, t = f;
+          if (e = me(), R(",")) {
+            for (e = a.createSequenceExpression([e]); u < D && R(","); )
+              j(), e.expressions.push(me());
+            a.markEnd(e, t);
+          }
+          return e;
+        }
+        function It() {
+          for (var e = [], t; u < D && !(R("}") || (t = Ie(), typeof t > "u")); )
+            e.push(t);
+          return e;
+        }
+        function Ue() {
+          var e, t;
+          return t = f, L("{"), e = It(), L("}"), a.markEnd(a.createBlockStatement(e), t);
+        }
+        function be() {
+          var e, t;
+          return t = f, e = j(), e.type !== c.Identifier && ge(e), a.markEnd(a.createIdentifier(e.value), t);
+        }
+        function Pt(e) {
+          var t = null, l, A;
+          return A = f, l = be(), E && ee(l.name) && W({}, p.StrictVarName), e === "const" ? (L("="), t = me()) : R("=") && (j(), t = me()), a.markEnd(a.createVariableDeclarator(l, t), A);
+        }
+        function Ge(e) {
+          var t = [];
+          do {
+            if (t.push(Pt(e)), !R(","))
+              break;
+            j();
+          } while (u < D);
+          return t;
+        }
+        function Tt() {
+          var e;
+          return ne("var"), e = Ge(), Ae(), a.createVariableDeclaration(e, "var");
+        }
+        function Nt(e) {
+          var t, l;
+          return l = f, ne(e), t = Ge(e), Ae(), a.markEnd(a.createVariableDeclaration(t, e), l);
+        }
+        function Rt() {
+          return L(";"), a.createEmptyStatement();
+        }
+        function Lt() {
+          var e = ue();
+          return Ae(), a.createExpressionStatement(e);
+        }
+        function Mt() {
+          var e, t, l;
+          return ne("if"), L("("), e = ue(), L(")"), t = ve(), se("else") ? (j(), l = ve()) : l = null, a.createIfStatement(e, t, l);
+        }
+        function Ut() {
+          var e, t, l;
+          return ne("do"), l = b.inIteration, b.inIteration = !0, e = ve(), b.inIteration = l, ne("while"), L("("), t = ue(), L(")"), R(";") && j(), a.createDoWhileStatement(e, t);
+        }
+        function jt() {
+          var e, t, l;
+          return ne("while"), L("("), e = ue(), L(")"), l = b.inIteration, b.inIteration = !0, t = ve(), b.inIteration = l, a.createWhileStatement(e, t);
+        }
+        function $t() {
+          var e, t, l;
+          return l = f, e = j(), t = Ge(), a.markEnd(a.createVariableDeclaration(t, e.value), l);
+        }
+        function Ht() {
+          var e, t, l, A, k, O, H;
+          return e = t = l = null, ne("for"), L("("), R(";") ? j() : (se("var") || se("let") ? (b.allowIn = !1, e = $t(), b.allowIn = !0, e.declarations.length === 1 && se("in") && (j(), A = e, k = ue(), e = null)) : (b.allowIn = !1, e = ue(), b.allowIn = !0, se("in") && (Le(e) || W({}, p.InvalidLHSInForIn), j(), A = e, k = ue(), e = null)), typeof A > "u" && L(";")), typeof A > "u" && (R(";") || (t = ue()), L(";"), R(")") || (l = ue())), L(")"), H = b.inIteration, b.inIteration = !0, O = ve(), b.inIteration = H, typeof A > "u" ? a.createForStatement(e, t, l, O) : a.createForInStatement(A, k, O);
+        }
+        function zt() {
+          var e = null, t;
+          return ne("continue"), d.charCodeAt(u) === 59 ? (j(), b.inIteration || $({}, p.IllegalContinue), a.createContinueStatement(null)) : Oe() ? (b.inIteration || $({}, p.IllegalContinue), a.createContinueStatement(null)) : (f.type === c.Identifier && (e = be(), t = "$" + e.name, Object.prototype.hasOwnProperty.call(b.labelSet, t) || $({}, p.UnknownLabel, e.name)), Ae(), e === null && !b.inIteration && $({}, p.IllegalContinue), a.createContinueStatement(e));
+        }
+        function qt() {
+          var e = null, t;
+          return ne("break"), d.charCodeAt(u) === 59 ? (j(), b.inIteration || b.inSwitch || $({}, p.IllegalBreak), a.createBreakStatement(null)) : Oe() ? (b.inIteration || b.inSwitch || $({}, p.IllegalBreak), a.createBreakStatement(null)) : (f.type === c.Identifier && (e = be(), t = "$" + e.name, Object.prototype.hasOwnProperty.call(b.labelSet, t) || $({}, p.UnknownLabel, e.name)), Ae(), e === null && !(b.inIteration || b.inSwitch) && $({}, p.IllegalBreak), a.createBreakStatement(e));
+        }
+        function Gt() {
+          var e = null;
+          return ne("return"), b.inFunctionBody || W({}, p.IllegalReturn), d.charCodeAt(u) === 32 && q(d.charCodeAt(u + 1)) ? (e = ue(), Ae(), a.createReturnStatement(e)) : Oe() ? a.createReturnStatement(null) : (R(";") || !R("}") && f.type !== c.EOF && (e = ue()), Ae(), a.createReturnStatement(e));
+        }
+        function Xt() {
+          var e, t;
+          return E && (_(), W({}, p.StrictModeWith)), ne("with"), L("("), e = ue(), L(")"), t = ve(), a.createWithStatement(e, t);
+        }
+        function Kt() {
+          var e, t = [], l, A;
+          for (A = f, se("default") ? (j(), e = null) : (ne("case"), e = ue()), L(":"); u < D && !(R("}") || se("default") || se("case")); )
+            l = ve(), t.push(l);
+          return a.markEnd(a.createSwitchCase(e, t), A);
+        }
+        function Wt() {
+          var e, t, l, A, k;
+          if (ne("switch"), L("("), e = ue(), L(")"), L("{"), t = [], R("}"))
+            return j(), a.createSwitchStatement(e, t);
+          for (A = b.inSwitch, b.inSwitch = !0, k = !1; u < D && !R("}"); )
+            l = Kt(), l.test === null && (k && $({}, p.MultipleDefaultsInSwitch), k = !0), t.push(l);
+          return b.inSwitch = A, L("}"), a.createSwitchStatement(e, t);
+        }
+        function Vt() {
+          var e;
+          return ne("throw"), Oe() && $({}, p.NewlineAfterThrow), e = ue(), Ae(), a.createThrowStatement(e);
+        }
+        function Jt() {
+          var e, t, l;
+          return l = f, ne("catch"), L("("), R(")") && ge(f), e = be(), E && ee(e.name) && W({}, p.StrictCatchVariable), L(")"), t = Ue(), a.markEnd(a.createCatchClause(e, t), l);
+        }
+        function Qt() {
+          var e, t = [], l = null;
+          return ne("try"), e = Ue(), se("catch") && t.push(Jt()), se("finally") && (j(), l = Ue()), t.length === 0 && !l && $({}, p.NoCatchOrFinally), a.createTryStatement(e, [], t, l);
+        }
+        function Yt() {
+          return ne("debugger"), Ae(), a.createDebuggerStatement();
+        }
+        function ve() {
+          var e = f.type, t, l, A, k;
+          if (e === c.EOF && ge(f), e === c.Punctuator && f.value === "{")
+            return Ue();
+          if (k = f, e === c.Punctuator)
+            switch (f.value) {
+              case ";":
+                return a.markEnd(Rt(), k);
+              case "(":
+                return a.markEnd(Lt(), k);
+            }
+          if (e === c.Keyword)
+            switch (f.value) {
+              case "break":
+                return a.markEnd(qt(), k);
+              case "continue":
+                return a.markEnd(zt(), k);
+              case "debugger":
+                return a.markEnd(Yt(), k);
+              case "do":
+                return a.markEnd(Ut(), k);
+              case "for":
+                return a.markEnd(Ht(), k);
+              case "function":
+                return a.markEnd(ct(), k);
+              case "if":
+                return a.markEnd(Mt(), k);
+              case "return":
+                return a.markEnd(Gt(), k);
+              case "switch":
+                return a.markEnd(Wt(), k);
+              case "throw":
+                return a.markEnd(Vt(), k);
+              case "try":
+                return a.markEnd(Qt(), k);
+              case "var":
+                return a.markEnd(Tt(), k);
+              case "while":
+                return a.markEnd(jt(), k);
+              case "with":
+                return a.markEnd(Xt(), k);
+            }
+          return t = ue(), t.type === C.Identifier && R(":") ? (j(), A = "$" + t.name, Object.prototype.hasOwnProperty.call(b.labelSet, A) && $({}, p.Redeclaration, "Label", t.name), b.labelSet[A] = !0, l = ve(), delete b.labelSet[A], a.markEnd(a.createLabeledStatement(t, l), k)) : (Ae(), a.markEnd(a.createExpressionStatement(t), k));
+        }
+        function Xe() {
+          var e, t = [], l, A, k, O, H, J, oe, ae;
+          for (ae = f, L("{"); u < D && !(f.type !== c.StringLiteral || (l = f, e = Ie(), t.push(e), e.expression.type !== C.Literal)); )
+            A = d.slice(l.start + 1, l.end - 1), A === "use strict" ? (E = !0, k && W(k, p.StrictOctalLiteral)) : !k && l.octal && (k = l);
+          for (O = b.labelSet, H = b.inIteration, J = b.inSwitch, oe = b.inFunctionBody, b.labelSet = {}, b.inIteration = !1, b.inSwitch = !1, b.inFunctionBody = !0; u < D && !(R("}") || (e = Ie(), typeof e > "u")); )
+            t.push(e);
+          return L("}"), b.labelSet = O, b.inIteration = H, b.inSwitch = J, b.inFunctionBody = oe, a.markEnd(a.createBlockStatement(t), ae);
+        }
+        function lt(e) {
+          var t, l = [], A, k, O, H, J;
+          if (L("("), !R(")"))
+            for (O = {}; u < D && (A = f, t = be(), H = "$" + A.value, E ? (ee(A.value) && (k = A, J = p.StrictParamName), Object.prototype.hasOwnProperty.call(O, H) && (k = A, J = p.StrictParamDupe)) : e || (ee(A.value) ? (e = A, J = p.StrictParamName) : re(A.value) ? (e = A, J = p.StrictReservedWord) : Object.prototype.hasOwnProperty.call(O, H) && (e = A, J = p.StrictParamDupe)), l.push(t), O[H] = !0, !R(")")); )
+              L(",");
+          return L(")"), {
+            params: l,
+            stricted: k,
+            firstRestricted: e,
+            message: J
+          };
+        }
+        function ct() {
+          var e, t = [], l, A, k, O, H, J, oe, ae;
+          return ae = f, ne("function"), A = f, e = be(), E ? ee(A.value) && W(A, p.StrictFunctionName) : ee(A.value) ? (H = A, J = p.StrictFunctionName) : re(A.value) && (H = A, J = p.StrictReservedWord), O = lt(H), t = O.params, k = O.stricted, H = O.firstRestricted, O.message && (J = O.message), oe = E, l = Xe(), E && H && $(H, J), E && k && W(k, J), E = oe, a.markEnd(a.createFunctionDeclaration(e, t, [], l), ae);
+        }
+        function Zt() {
+          var e, t = null, l, A, k, O, H = [], J, oe, ae;
+          return ae = f, ne("function"), R("(") || (e = f, t = be(), E ? ee(e.value) && W(e, p.StrictFunctionName) : ee(e.value) ? (A = e, k = p.StrictFunctionName) : re(e.value) && (A = e, k = p.StrictReservedWord)), O = lt(A), H = O.params, l = O.stricted, A = O.firstRestricted, O.message && (k = O.message), oe = E, J = Xe(), E && A && $(A, k), E && l && W(l, k), E = oe, a.markEnd(a.createFunctionExpression(t, H, [], J), ae);
+        }
+        function Ie() {
+          if (f.type === c.Keyword)
+            switch (f.value) {
+              case "const":
+              case "let":
+                return Nt(f.value);
+              case "function":
+                return ct();
+              default:
+                return ve();
+            }
+          if (f.type !== c.EOF)
+            return ve();
+        }
+        function er() {
+          for (var e, t = [], l, A, k; u < D && (l = f, !(l.type !== c.StringLiteral || (e = Ie(), t.push(e), e.expression.type !== C.Literal))); )
+            A = d.slice(l.start + 1, l.end - 1), A === "use strict" ? (E = !0, k && W(k, p.StrictOctalLiteral)) : !k && l.octal && (k = l);
+          for (; u < D && (e = Ie(), !(typeof e > "u")); )
+            t.push(e);
+          return t;
+        }
+        function tr() {
+          var e, t;
+          return _(), ze(), t = f, E = !1, e = er(), a.markEnd(a.createProgram(e), t);
+        }
+        function ft() {
+          var e, t, l, A = [];
+          for (e = 0; e < g.tokens.length; ++e)
+            t = g.tokens[e], l = {
+              type: t.type,
+              value: t.value
+            }, g.range && (l.range = t.range), g.loc && (l.loc = t.loc), A.push(l);
+          g.tokens = A;
+        }
+        function rr(e, t) {
+          var l, A, k;
+          l = String, typeof e != "string" && !(e instanceof String) && (e = l(e)), a = F, d = e, u = 0, S = d.length > 0 ? 1 : 0, B = 0, D = d.length, f = null, b = {
+            allowIn: !0,
+            labelSet: {},
+            inFunctionBody: !1,
+            inIteration: !1,
+            inSwitch: !1,
+            lastCommentStart: -1
+          }, g = {}, t = t || {}, t.tokens = !0, g.tokens = [], g.tokenize = !0, g.openParenToken = -1, g.openCurlyToken = -1, g.range = typeof t.range == "boolean" && t.range, g.loc = typeof t.loc == "boolean" && t.loc, typeof t.comment == "boolean" && t.comment && (g.comments = []), typeof t.tolerant == "boolean" && t.tolerant && (g.errors = []);
+          try {
+            if (ze(), f.type === c.EOF)
+              return g.tokens;
+            for (A = j(); f.type !== c.EOF; )
+              try {
+                A = j();
+              } catch (O) {
+                if (A = f, g.errors) {
+                  g.errors.push(O);
+                  break;
+                } else
+                  throw O;
+              }
+            ft(), k = g.tokens, typeof g.comments < "u" && (k.comments = g.comments), typeof g.errors < "u" && (k.errors = g.errors);
+          } catch (O) {
+            throw O;
+          } finally {
+            g = {};
+          }
+          return k;
+        }
+        function nr(e, t) {
+          var l, A;
+          A = String, typeof e != "string" && !(e instanceof String) && (e = A(e)), a = F, d = e, u = 0, S = d.length > 0 ? 1 : 0, B = 0, D = d.length, f = null, b = {
+            allowIn: !0,
+            labelSet: {},
+            inFunctionBody: !1,
+            inIteration: !1,
+            inSwitch: !1,
+            lastCommentStart: -1
+          }, g = {}, typeof t < "u" && (g.range = typeof t.range == "boolean" && t.range, g.loc = typeof t.loc == "boolean" && t.loc, g.attachComment = typeof t.attachComment == "boolean" && t.attachComment, g.loc && t.source !== null && t.source !== void 0 && (g.source = A(t.source)), typeof t.tokens == "boolean" && t.tokens && (g.tokens = []), typeof t.comment == "boolean" && t.comment && (g.comments = []), typeof t.tolerant == "boolean" && t.tolerant && (g.errors = []), g.attachComment && (g.range = !0, g.comments = [], g.bottomRightStack = [], g.trailingComments = [], g.leadingComments = []));
+          try {
+            l = tr(), typeof g.comments < "u" && (l.comments = g.comments), typeof g.tokens < "u" && (ft(), l.tokens = g.tokens), typeof g.errors < "u" && (l.errors = g.errors);
+          } catch (k) {
+            throw k;
+          } finally {
+            g = {};
+          }
+          return l;
+        }
+        s.version = "1.2.2", s.tokenize = rr, s.parse = nr, s.Syntax = function() {
+          var e, t = {};
+          typeof Object.create == "function" && (t = /* @__PURE__ */ Object.create(null));
+          for (e in C)
+            C.hasOwnProperty(e) && (t[e] = C[e]);
+          return typeof Object.freeze == "function" && Object.freeze(t), t;
+        }();
+      });
+    }, {}], 1: [function(n, o, h) {
+      (function(s) {
+        var c = function() {
+          var x = {
+            trace: function() {
+            },
+            yy: {},
+            symbols_: { error: 2, JSON_PATH: 3, DOLLAR: 4, PATH_COMPONENTS: 5, LEADING_CHILD_MEMBER_EXPRESSION: 6, PATH_COMPONENT: 7, MEMBER_COMPONENT: 8, SUBSCRIPT_COMPONENT: 9, CHILD_MEMBER_COMPONENT: 10, DESCENDANT_MEMBER_COMPONENT: 11, DOT: 12, MEMBER_EXPRESSION: 13, DOT_DOT: 14, STAR: 15, IDENTIFIER: 16, SCRIPT_EXPRESSION: 17, INTEGER: 18, END: 19, CHILD_SUBSCRIPT_COMPONENT: 20, DESCENDANT_SUBSCRIPT_COMPONENT: 21, "[": 22, SUBSCRIPT: 23, "]": 24, SUBSCRIPT_EXPRESSION: 25, SUBSCRIPT_EXPRESSION_LIST: 26, SUBSCRIPT_EXPRESSION_LISTABLE: 27, ",": 28, STRING_LITERAL: 29, ARRAY_SLICE: 30, FILTER_EXPRESSION: 31, QQ_STRING: 32, Q_STRING: 33, $accept: 0, $end: 1 },
+            terminals_: { 2: "error", 4: "DOLLAR", 12: "DOT", 14: "DOT_DOT", 15: "STAR", 16: "IDENTIFIER", 17: "SCRIPT_EXPRESSION", 18: "INTEGER", 19: "END", 22: "[", 24: "]", 28: ",", 30: "ARRAY_SLICE", 31: "FILTER_EXPRESSION", 32: "QQ_STRING", 33: "Q_STRING" },
+            productions_: [0, [3, 1], [3, 2], [3, 1], [3, 2], [5, 1], [5, 2], [7, 1], [7, 1], [8, 1], [8, 1], [10, 2], [6, 1], [11, 2], [13, 1], [13, 1], [13, 1], [13, 1], [13, 1], [9, 1], [9, 1], [20, 3], [21, 4], [23, 1], [23, 1], [26, 1], [26, 3], [27, 1], [27, 1], [27, 1], [25, 1], [25, 1], [25, 1], [29, 1], [29, 1]],
+            performAction: function(y, F, d, E, u, S, B) {
+              E.ast || (E.ast = v, v.initialize());
+              var D = S.length - 1;
+              switch (u) {
+                case 1:
+                  return E.ast.set({ expression: { type: "root", value: S[D] } }), E.ast.unshift(), E.ast.yield();
+                case 2:
+                  return E.ast.set({ expression: { type: "root", value: S[D - 1] } }), E.ast.unshift(), E.ast.yield();
+                case 3:
+                  return E.ast.unshift(), E.ast.yield();
+                case 4:
+                  return E.ast.set({ operation: "member", scope: "child", expression: { type: "identifier", value: S[D - 1] } }), E.ast.unshift(), E.ast.yield();
+                case 5:
+                  break;
+                case 6:
+                  break;
+                case 7:
+                  E.ast.set({ operation: "member" }), E.ast.push();
+                  break;
+                case 8:
+                  E.ast.set({ operation: "subscript" }), E.ast.push();
+                  break;
+                case 9:
+                  E.ast.set({ scope: "child" });
+                  break;
+                case 10:
+                  E.ast.set({ scope: "descendant" });
+                  break;
+                case 11:
+                  break;
+                case 12:
+                  E.ast.set({ scope: "child", operation: "member" });
+                  break;
+                case 13:
+                  break;
+                case 14:
+                  E.ast.set({ expression: { type: "wildcard", value: S[D] } });
+                  break;
+                case 15:
+                  E.ast.set({ expression: { type: "identifier", value: S[D] } });
+                  break;
+                case 16:
+                  E.ast.set({ expression: { type: "script_expression", value: S[D] } });
+                  break;
+                case 17:
+                  E.ast.set({ expression: { type: "numeric_literal", value: parseInt(S[D]) } });
+                  break;
+                case 18:
+                  break;
+                case 19:
+                  E.ast.set({ scope: "child" });
+                  break;
+                case 20:
+                  E.ast.set({ scope: "descendant" });
+                  break;
+                case 21:
+                  break;
+                case 22:
+                  break;
+                case 23:
+                  break;
+                case 24:
+                  S[D].length > 1 ? E.ast.set({ expression: { type: "union", value: S[D] } }) : this.$ = S[D];
+                  break;
+                case 25:
+                  this.$ = [S[D]];
+                  break;
+                case 26:
+                  this.$ = S[D - 2].concat(S[D]);
+                  break;
+                case 27:
+                  this.$ = { expression: { type: "numeric_literal", value: parseInt(S[D]) } }, E.ast.set(this.$);
+                  break;
+                case 28:
+                  this.$ = { expression: { type: "string_literal", value: S[D] } }, E.ast.set(this.$);
+                  break;
+                case 29:
+                  this.$ = { expression: { type: "slice", value: S[D] } }, E.ast.set(this.$);
+                  break;
+                case 30:
+                  this.$ = { expression: { type: "wildcard", value: S[D] } }, E.ast.set(this.$);
+                  break;
+                case 31:
+                  this.$ = { expression: { type: "script_expression", value: S[D] } }, E.ast.set(this.$);
+                  break;
+                case 32:
+                  this.$ = { expression: { type: "filter_expression", value: S[D] } }, E.ast.set(this.$);
+                  break;
+                case 33:
+                  this.$ = S[D];
+                  break;
+                case 34:
+                  this.$ = S[D];
+                  break;
+              }
+            },
+            table: [{ 3: 1, 4: [1, 2], 6: 3, 13: 4, 15: [1, 5], 16: [1, 6], 17: [1, 7], 18: [1, 8], 19: [1, 9] }, { 1: [3] }, { 1: [2, 1], 5: 10, 7: 11, 8: 12, 9: 13, 10: 14, 11: 15, 12: [1, 18], 14: [1, 19], 20: 16, 21: 17, 22: [1, 20] }, { 1: [2, 3], 5: 21, 7: 11, 8: 12, 9: 13, 10: 14, 11: 15, 12: [1, 18], 14: [1, 19], 20: 16, 21: 17, 22: [1, 20] }, { 1: [2, 12], 12: [2, 12], 14: [2, 12], 22: [2, 12] }, { 1: [2, 14], 12: [2, 14], 14: [2, 14], 22: [2, 14] }, { 1: [2, 15], 12: [2, 15], 14: [2, 15], 22: [2, 15] }, { 1: [2, 16], 12: [2, 16], 14: [2, 16], 22: [2, 16] }, { 1: [2, 17], 12: [2, 17], 14: [2, 17], 22: [2, 17] }, { 1: [2, 18], 12: [2, 18], 14: [2, 18], 22: [2, 18] }, { 1: [2, 2], 7: 22, 8: 12, 9: 13, 10: 14, 11: 15, 12: [1, 18], 14: [1, 19], 20: 16, 21: 17, 22: [1, 20] }, { 1: [2, 5], 12: [2, 5], 14: [2, 5], 22: [2, 5] }, { 1: [2, 7], 12: [2, 7], 14: [2, 7], 22: [2, 7] }, { 1: [2, 8], 12: [2, 8], 14: [2, 8], 22: [2, 8] }, { 1: [2, 9], 12: [2, 9], 14: [2, 9], 22: [2, 9] }, { 1: [2, 10], 12: [2, 10], 14: [2, 10], 22: [2, 10] }, { 1: [2, 19], 12: [2, 19], 14: [2, 19], 22: [2, 19] }, { 1: [2, 20], 12: [2, 20], 14: [2, 20], 22: [2, 20] }, { 13: 23, 15: [1, 5], 16: [1, 6], 17: [1, 7], 18: [1, 8], 19: [1, 9] }, { 13: 24, 15: [1, 5], 16: [1, 6], 17: [1, 7], 18: [1, 8], 19: [1, 9], 22: [1, 25] }, { 15: [1, 29], 17: [1, 30], 18: [1, 33], 23: 26, 25: 27, 26: 28, 27: 32, 29: 34, 30: [1, 35], 31: [1, 31], 32: [1, 36], 33: [1, 37] }, { 1: [2, 4], 7: 22, 8: 12, 9: 13, 10: 14, 11: 15, 12: [1, 18], 14: [1, 19], 20: 16, 21: 17, 22: [1, 20] }, { 1: [2, 6], 12: [2, 6], 14: [2, 6], 22: [2, 6] }, { 1: [2, 11], 12: [2, 11], 14: [2, 11], 22: [2, 11] }, { 1: [2, 13], 12: [2, 13], 14: [2, 13], 22: [2, 13] }, { 15: [1, 29], 17: [1, 30], 18: [1, 33], 23: 38, 25: 27, 26: 28, 27: 32, 29: 34, 30: [1, 35], 31: [1, 31], 32: [1, 36], 33: [1, 37] }, { 24: [1, 39] }, { 24: [2, 23] }, { 24: [2, 24], 28: [1, 40] }, { 24: [2, 30] }, { 24: [2, 31] }, { 24: [2, 32] }, { 24: [2, 25], 28: [2, 25] }, { 24: [2, 27], 28: [2, 27] }, { 24: [2, 28], 28: [2, 28] }, { 24: [2, 29], 28: [2, 29] }, { 24: [2, 33], 28: [2, 33] }, { 24: [2, 34], 28: [2, 34] }, { 24: [1, 41] }, { 1: [2, 21], 12: [2, 21], 14: [2, 21], 22: [2, 21] }, { 18: [1, 33], 27: 42, 29: 34, 30: [1, 35], 32: [1, 36], 33: [1, 37] }, { 1: [2, 22], 12: [2, 22], 14: [2, 22], 22: [2, 22] }, { 24: [2, 26], 28: [2, 26] }],
+            defaultActions: { 27: [2, 23], 29: [2, 30], 30: [2, 31], 31: [2, 32] },
+            parseError: function(y, F) {
+              if (F.recoverable)
+                this.trace(y);
+              else
+                throw new Error(y);
+            },
+            parse: function(y) {
+              var F = this, d = [0], E = [null], u = [], S = this.table, B = "", D = 0, a = 0, f = 2, b = 1, g = u.slice.call(arguments, 1);
+              this.lexer.setInput(y), this.lexer.yy = this.yy, this.yy.lexer = this.lexer, this.yy.parser = this, typeof this.lexer.yylloc > "u" && (this.lexer.yylloc = {});
+              var I = this.lexer.yylloc;
+              u.push(I);
+              var M = this.lexer.options && this.lexer.options.ranges;
+              typeof this.yy.parseError == "function" ? this.parseError = this.yy.parseError : this.parseError = Object.getPrototypeOf(this).parseError;
+              function z() {
+                var he;
+                return he = F.lexer.lex() || b, typeof he != "number" && (he = F.symbols_[he] || he), he;
+              }
+              for (var T, N, U, q, V = {}, fe, re, ee, pe; ; ) {
+                if (N = d[d.length - 1], this.defaultActions[N] ? U = this.defaultActions[N] : ((T === null || typeof T > "u") && (T = z()), U = S[N] && S[N][T]), typeof U > "u" || !U.length || !U[0]) {
+                  var ce = "";
+                  pe = [];
+                  for (fe in S[N])
+                    this.terminals_[fe] && fe > f && pe.push("'" + this.terminals_[fe] + "'");
+                  this.lexer.showPosition ? ce = "Parse error on line " + (D + 1) + `:
+` + this.lexer.showPosition() + `
+Expecting ` + pe.join(", ") + ", got '" + (this.terminals_[T] || T) + "'" : ce = "Parse error on line " + (D + 1) + ": Unexpected " + (T == b ? "end of input" : "'" + (this.terminals_[T] || T) + "'"), this.parseError(ce, {
+                    text: this.lexer.match,
+                    token: this.terminals_[T] || T,
+                    line: this.lexer.yylineno,
+                    loc: I,
+                    expected: pe
+                  });
+                }
+                if (U[0] instanceof Array && U.length > 1)
+                  throw new Error("Parse Error: multiple actions possible at state: " + N + ", token: " + T);
+                switch (U[0]) {
+                  case 1:
+                    d.push(T), E.push(this.lexer.yytext), u.push(this.lexer.yylloc), d.push(U[1]), T = null, a = this.lexer.yyleng, B = this.lexer.yytext, D = this.lexer.yylineno, I = this.lexer.yylloc;
+                    break;
+                  case 2:
+                    if (re = this.productions_[U[1]][1], V.$ = E[E.length - re], V._$ = {
+                      first_line: u[u.length - (re || 1)].first_line,
+                      last_line: u[u.length - 1].last_line,
+                      first_column: u[u.length - (re || 1)].first_column,
+                      last_column: u[u.length - 1].last_column
+                    }, M && (V._$.range = [
+                      u[u.length - (re || 1)].range[0],
+                      u[u.length - 1].range[1]
+                    ]), q = this.performAction.apply(V, [
+                      B,
+                      a,
+                      D,
+                      this.yy,
+                      U[1],
+                      E,
+                      u
+                    ].concat(g)), typeof q < "u")
+                      return q;
+                    re && (d = d.slice(0, -1 * re * 2), E = E.slice(0, -1 * re), u = u.slice(0, -1 * re)), d.push(this.productions_[U[1]][0]), E.push(V.$), u.push(V._$), ee = S[d[d.length - 2]][d[d.length - 1]], d.push(ee);
+                    break;
+                  case 3:
+                    return !0;
+                }
+              }
+              return !0;
+            }
+          }, v = {
+            initialize: function() {
+              this._nodes = [], this._node = {}, this._stash = [];
+            },
+            set: function(p) {
+              for (var y in p)
+                this._node[y] = p[y];
+              return this._node;
+            },
+            node: function(p) {
+              return arguments.length && (this._node = p), this._node;
+            },
+            push: function() {
+              this._nodes.push(this._node), this._node = {};
+            },
+            unshift: function() {
+              this._nodes.unshift(this._node), this._node = {};
+            },
+            yield: function() {
+              var p = this._nodes;
+              return this.initialize(), p;
+            }
+          }, C = function() {
+            var p = {
+              EOF: 1,
+              parseError: function(F, d) {
+                if (this.yy.parser)
+                  this.yy.parser.parseError(F, d);
+                else
+                  throw new Error(F);
+              },
+              // resets the lexer, sets new input
+              setInput: function(y) {
+                return this._input = y, this._more = this._backtrack = this.done = !1, this.yylineno = this.yyleng = 0, this.yytext = this.matched = this.match = "", this.conditionStack = ["INITIAL"], this.yylloc = {
+                  first_line: 1,
+                  first_column: 0,
+                  last_line: 1,
+                  last_column: 0
+                }, this.options.ranges && (this.yylloc.range = [0, 0]), this.offset = 0, this;
+              },
+              // consumes and returns one char from the input
+              input: function() {
+                var y = this._input[0];
+                this.yytext += y, this.yyleng++, this.offset++, this.match += y, this.matched += y;
+                var F = y.match(/(?:\r\n?|\n).*/g);
+                return F ? (this.yylineno++, this.yylloc.last_line++) : this.yylloc.last_column++, this.options.ranges && this.yylloc.range[1]++, this._input = this._input.slice(1), y;
+              },
+              // unshifts one char (or a string) into the input
+              unput: function(y) {
+                var F = y.length, d = y.split(/(?:\r\n?|\n)/g);
+                this._input = y + this._input, this.yytext = this.yytext.substr(0, this.yytext.length - F - 1), this.offset -= F;
+                var E = this.match.split(/(?:\r\n?|\n)/g);
+                this.match = this.match.substr(0, this.match.length - 1), this.matched = this.matched.substr(0, this.matched.length - 1), d.length - 1 && (this.yylineno -= d.length - 1);
+                var u = this.yylloc.range;
+                return this.yylloc = {
+                  first_line: this.yylloc.first_line,
+                  last_line: this.yylineno + 1,
+                  first_column: this.yylloc.first_column,
+                  last_column: d ? (d.length === E.length ? this.yylloc.first_column : 0) + E[E.length - d.length].length - d[0].length : this.yylloc.first_column - F
+                }, this.options.ranges && (this.yylloc.range = [u[0], u[0] + this.yyleng - F]), this.yyleng = this.yytext.length, this;
+              },
+              // When called from action, caches matched text and appends it on next action
+              more: function() {
+                return this._more = !0, this;
+              },
+              // When called from action, signals the lexer that this rule fails to match the input, so the next matching rule (regex) should be tested instead.
+              reject: function() {
+                if (this.options.backtrack_lexer)
+                  this._backtrack = !0;
+                else
+                  return this.parseError("Lexical error on line " + (this.yylineno + 1) + `. You can only invoke reject() in the lexer when the lexer is of the backtracking persuasion (options.backtrack_lexer = true).
+` + this.showPosition(), {
+                    text: "",
+                    token: null,
+                    line: this.yylineno
+                  });
+                return this;
+              },
+              // retain first n characters of the match
+              less: function(y) {
+                this.unput(this.match.slice(y));
+              },
+              // displays already matched input, i.e. for error messages
+              pastInput: function() {
+                var y = this.matched.substr(0, this.matched.length - this.match.length);
+                return (y.length > 20 ? "..." : "") + y.substr(-20).replace(/\n/g, "");
+              },
+              // displays upcoming input, i.e. for error messages
+              upcomingInput: function() {
+                var y = this.match;
+                return y.length < 20 && (y += this._input.substr(0, 20 - y.length)), (y.substr(0, 20) + (y.length > 20 ? "..." : "")).replace(/\n/g, "");
+              },
+              // displays the character position where the lexing error occurred, i.e. for error messages
+              showPosition: function() {
+                var y = this.pastInput(), F = new Array(y.length + 1).join("-");
+                return y + this.upcomingInput() + `
+` + F + "^";
+              },
+              // test the lexed token: return FALSE when not a match, otherwise return token
+              test_match: function(y, F) {
+                var d, E, u;
+                if (this.options.backtrack_lexer && (u = {
+                  yylineno: this.yylineno,
+                  yylloc: {
+                    first_line: this.yylloc.first_line,
+                    last_line: this.last_line,
+                    first_column: this.yylloc.first_column,
+                    last_column: this.yylloc.last_column
+                  },
+                  yytext: this.yytext,
+                  match: this.match,
+                  matches: this.matches,
+                  matched: this.matched,
+                  yyleng: this.yyleng,
+                  offset: this.offset,
+                  _more: this._more,
+                  _input: this._input,
+                  yy: this.yy,
+                  conditionStack: this.conditionStack.slice(0),
+                  done: this.done
+                }, this.options.ranges && (u.yylloc.range = this.yylloc.range.slice(0))), E = y[0].match(/(?:\r\n?|\n).*/g), E && (this.yylineno += E.length), this.yylloc = {
+                  first_line: this.yylloc.last_line,
+                  last_line: this.yylineno + 1,
+                  first_column: this.yylloc.last_column,
+                  last_column: E ? E[E.length - 1].length - E[E.length - 1].match(/\r?\n?/)[0].length : this.yylloc.last_column + y[0].length
+                }, this.yytext += y[0], this.match += y[0], this.matches = y, this.yyleng = this.yytext.length, this.options.ranges && (this.yylloc.range = [this.offset, this.offset += this.yyleng]), this._more = !1, this._backtrack = !1, this._input = this._input.slice(y[0].length), this.matched += y[0], d = this.performAction.call(this, this.yy, this, F, this.conditionStack[this.conditionStack.length - 1]), this.done && this._input && (this.done = !1), d)
+                  return d;
+                if (this._backtrack) {
+                  for (var S in u)
+                    this[S] = u[S];
+                  return !1;
+                }
+                return !1;
+              },
+              // return next match in input
+              next: function() {
+                if (this.done)
+                  return this.EOF;
+                this._input || (this.done = !0);
+                var y, F, d, E;
+                this._more || (this.yytext = "", this.match = "");
+                for (var u = this._currentRules(), S = 0; S < u.length; S++)
+                  if (d = this._input.match(this.rules[u[S]]), d && (!F || d[0].length > F[0].length)) {
+                    if (F = d, E = S, this.options.backtrack_lexer) {
+                      if (y = this.test_match(d, u[S]), y !== !1)
+                        return y;
+                      if (this._backtrack) {
+                        F = !1;
+                        continue;
+                      } else
+                        return !1;
+                    } else if (!this.options.flex)
+                      break;
+                  }
+                return F ? (y = this.test_match(F, u[E]), y !== !1 ? y : !1) : this._input === "" ? this.EOF : this.parseError("Lexical error on line " + (this.yylineno + 1) + `. Unrecognized text.
+` + this.showPosition(), {
+                  text: "",
+                  token: null,
+                  line: this.yylineno
+                });
+              },
+              // return next match that has a token
+              lex: function() {
+                var F = this.next();
+                return F || this.lex();
+              },
+              // activates a new lexer condition state (pushes the new lexer condition state onto the condition stack)
+              begin: function(F) {
+                this.conditionStack.push(F);
+              },
+              // pop the previously active lexer condition state off the condition stack
+              popState: function() {
+                var F = this.conditionStack.length - 1;
+                return F > 0 ? this.conditionStack.pop() : this.conditionStack[0];
+              },
+              // produce the lexer rule set which is active for the currently active lexer condition state
+              _currentRules: function() {
+                return this.conditionStack.length && this.conditionStack[this.conditionStack.length - 1] ? this.conditions[this.conditionStack[this.conditionStack.length - 1]].rules : this.conditions.INITIAL.rules;
+              },
+              // return the currently active lexer condition state; when an index argument is provided it produces the N-th previous condition state, if available
+              topState: function(F) {
+                return F = this.conditionStack.length - 1 - Math.abs(F || 0), F >= 0 ? this.conditionStack[F] : "INITIAL";
+              },
+              // alias for begin(condition)
+              pushState: function(F) {
+                this.begin(F);
+              },
+              // return the number of states currently on the stack
+              stateStackSize: function() {
+                return this.conditionStack.length;
+              },
+              options: {},
+              performAction: function(F, d, E, u) {
+                switch (E) {
+                  case 0:
+                    return 4;
+                  case 1:
+                    return 14;
+                  case 2:
+                    return 12;
+                  case 3:
+                    return 15;
+                  case 4:
+                    return 16;
+                  case 5:
+                    return 22;
+                  case 6:
+                    return 24;
+                  case 7:
+                    return 28;
+                  case 8:
+                    return 30;
+                  case 9:
+                    return 18;
+                  case 10:
+                    return d.yytext = d.yytext.substr(1, d.yyleng - 2), 32;
+                  case 11:
+                    return d.yytext = d.yytext.substr(1, d.yyleng - 2), 33;
+                  case 12:
+                    return 17;
+                  case 13:
+                    return 31;
+                }
+              },
+              rules: [/^(?:\$)/, /^(?:\.\.)/, /^(?:\.)/, /^(?:\*)/, /^(?:[a-zA-Z_]+[a-zA-Z0-9_]*)/, /^(?:\[)/, /^(?:\])/, /^(?:,)/, /^(?:((-?(?:0|[1-9][0-9]*)))?\:((-?(?:0|[1-9][0-9]*)))?(\:((-?(?:0|[1-9][0-9]*)))?)?)/, /^(?:(-?(?:0|[1-9][0-9]*)))/, /^(?:"(?:\\["bfnrt/\\]|\\u[a-fA-F0-9]{4}|[^"\\])*")/, /^(?:'(?:\\['bfnrt/\\]|\\u[a-fA-F0-9]{4}|[^'\\])*')/, /^(?:\(.+?\)(?=\]))/, /^(?:\?\(.+?\)(?=\]))/],
+              conditions: { INITIAL: { rules: [0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13], inclusive: !0 } }
+            };
+            return p;
+          }();
+          x.lexer = C;
+          function m() {
+            this.yy = {};
+          }
+          return m.prototype = x, x.Parser = m, new m();
+        }();
+        typeof n < "u" && typeof h < "u" && (h.parser = c, h.Parser = c.Parser, h.parse = function() {
+          return c.parse.apply(c, arguments);
+        }, h.main = function(v) {
+          v[1] || (console.log("Usage: " + v[0] + " FILE"), s.exit(1));
+          var C = n("fs").readFileSync(n("path").normalize(v[1]), "utf8");
+          return h.parser.parse(C);
+        }, typeof o < "u" && n.main === o && h.main(s.argv.slice(1)));
+      }).call(this, n("_process"));
+    }, { _process: 14, fs: 12, path: 13 }], 2: [function(n, o, h) {
+      o.exports = {
+        identifier: "[a-zA-Z_]+[a-zA-Z0-9_]*",
+        integer: "-?(?:0|[1-9][0-9]*)",
+        qq_string: '"(?:\\\\["bfnrt/\\\\]|\\\\u[a-fA-F0-9]{4}|[^"\\\\])*"',
+        q_string: "'(?:\\\\['bfnrt/\\\\]|\\\\u[a-fA-F0-9]{4}|[^'\\\\])*'"
+      };
+    }, {}], 3: [function(n, o, h) {
+      var s = n("./dict"), c = n("fs"), x = {
+        lex: {
+          macros: {
+            esc: "\\\\",
+            int: s.integer
+          },
+          rules: [
+            ["\\$", "return 'DOLLAR'"],
+            ["\\.\\.", "return 'DOT_DOT'"],
+            ["\\.", "return 'DOT'"],
+            ["\\*", "return 'STAR'"],
+            [s.identifier, "return 'IDENTIFIER'"],
+            ["\\[", "return '['"],
+            ["\\]", "return ']'"],
+            [",", "return ','"],
+            ["({int})?\\:({int})?(\\:({int})?)?", "return 'ARRAY_SLICE'"],
+            ["{int}", "return 'INTEGER'"],
+            [s.qq_string, "yytext = yytext.substr(1,yyleng-2); return 'QQ_STRING';"],
+            [s.q_string, "yytext = yytext.substr(1,yyleng-2); return 'Q_STRING';"],
+            ["\\(.+?\\)(?=\\])", "return 'SCRIPT_EXPRESSION'"],
+            ["\\?\\(.+?\\)(?=\\])", "return 'FILTER_EXPRESSION'"]
+          ]
+        },
+        start: "JSON_PATH",
+        bnf: {
+          JSON_PATH: [
+            ["DOLLAR", 'yy.ast.set({ expression: { type: "root", value: $1 } }); yy.ast.unshift(); return yy.ast.yield()'],
+            ["DOLLAR PATH_COMPONENTS", 'yy.ast.set({ expression: { type: "root", value: $1 } }); yy.ast.unshift(); return yy.ast.yield()'],
+            ["LEADING_CHILD_MEMBER_EXPRESSION", "yy.ast.unshift(); return yy.ast.yield()"],
+            ["LEADING_CHILD_MEMBER_EXPRESSION PATH_COMPONENTS", 'yy.ast.set({ operation: "member", scope: "child", expression: { type: "identifier", value: $1 }}); yy.ast.unshift(); return yy.ast.yield()']
+          ],
+          PATH_COMPONENTS: [
+            ["PATH_COMPONENT", ""],
+            ["PATH_COMPONENTS PATH_COMPONENT", ""]
+          ],
+          PATH_COMPONENT: [
+            ["MEMBER_COMPONENT", 'yy.ast.set({ operation: "member" }); yy.ast.push()'],
+            ["SUBSCRIPT_COMPONENT", 'yy.ast.set({ operation: "subscript" }); yy.ast.push() ']
+          ],
+          MEMBER_COMPONENT: [
+            ["CHILD_MEMBER_COMPONENT", 'yy.ast.set({ scope: "child" })'],
+            ["DESCENDANT_MEMBER_COMPONENT", 'yy.ast.set({ scope: "descendant" })']
+          ],
+          CHILD_MEMBER_COMPONENT: [
+            ["DOT MEMBER_EXPRESSION", ""]
+          ],
+          LEADING_CHILD_MEMBER_EXPRESSION: [
+            ["MEMBER_EXPRESSION", 'yy.ast.set({ scope: "child", operation: "member" })']
+          ],
+          DESCENDANT_MEMBER_COMPONENT: [
+            ["DOT_DOT MEMBER_EXPRESSION", ""]
+          ],
+          MEMBER_EXPRESSION: [
+            ["STAR", 'yy.ast.set({ expression: { type: "wildcard", value: $1 } })'],
+            ["IDENTIFIER", 'yy.ast.set({ expression: { type: "identifier", value: $1 } })'],
+            ["SCRIPT_EXPRESSION", 'yy.ast.set({ expression: { type: "script_expression", value: $1 } })'],
+            ["INTEGER", 'yy.ast.set({ expression: { type: "numeric_literal", value: parseInt($1) } })'],
+            ["END", ""]
+          ],
+          SUBSCRIPT_COMPONENT: [
+            ["CHILD_SUBSCRIPT_COMPONENT", 'yy.ast.set({ scope: "child" })'],
+            ["DESCENDANT_SUBSCRIPT_COMPONENT", 'yy.ast.set({ scope: "descendant" })']
+          ],
+          CHILD_SUBSCRIPT_COMPONENT: [
+            ["[ SUBSCRIPT ]", ""]
+          ],
+          DESCENDANT_SUBSCRIPT_COMPONENT: [
+            ["DOT_DOT [ SUBSCRIPT ]", ""]
+          ],
+          SUBSCRIPT: [
+            ["SUBSCRIPT_EXPRESSION", ""],
+            ["SUBSCRIPT_EXPRESSION_LIST", '$1.length > 1? yy.ast.set({ expression: { type: "union", value: $1 } }) : $$ = $1']
+          ],
+          SUBSCRIPT_EXPRESSION_LIST: [
+            ["SUBSCRIPT_EXPRESSION_LISTABLE", "$$ = [$1]"],
+            ["SUBSCRIPT_EXPRESSION_LIST , SUBSCRIPT_EXPRESSION_LISTABLE", "$$ = $1.concat($3)"]
+          ],
+          SUBSCRIPT_EXPRESSION_LISTABLE: [
+            ["INTEGER", '$$ = { expression: { type: "numeric_literal", value: parseInt($1) } }; yy.ast.set($$)'],
+            ["STRING_LITERAL", '$$ = { expression: { type: "string_literal", value: $1 } }; yy.ast.set($$)'],
+            ["ARRAY_SLICE", '$$ = { expression: { type: "slice", value: $1 } }; yy.ast.set($$)']
+          ],
+          SUBSCRIPT_EXPRESSION: [
+            ["STAR", '$$ = { expression: { type: "wildcard", value: $1 } }; yy.ast.set($$)'],
+            ["SCRIPT_EXPRESSION", '$$ = { expression: { type: "script_expression", value: $1 } }; yy.ast.set($$)'],
+            ["FILTER_EXPRESSION", '$$ = { expression: { type: "filter_expression", value: $1 } }; yy.ast.set($$)']
+          ],
+          STRING_LITERAL: [
+            ["QQ_STRING", "$$ = $1"],
+            ["Q_STRING", "$$ = $1"]
+          ]
+        }
+      };
+      c.readFileSync && (x.moduleInclude = c.readFileSync(n.resolve("../include/module.js")), x.actionInclude = c.readFileSync(n.resolve("../include/action.js"))), o.exports = x;
+    }, { "./dict": 2, fs: 12 }], 4: [function(n, o, h) {
+      var s = n("./aesprim"), c = n("./slice"), x = n("static-eval"), v = n("underscore").uniq, C = function() {
+        return this.initialize.apply(this, arguments);
+      };
+      C.prototype.initialize = function() {
+        this.traverse = F(!0), this.descend = F();
+      }, C.prototype.keys = Object.keys, C.prototype.resolve = function(D) {
+        var a = [D.operation, D.scope, D.expression.type].join("-"), f = this._fns[a];
+        if (!f)
+          throw new Error("couldn't resolve key: " + a);
+        return f.bind(this);
+      }, C.prototype.register = function(D, a) {
+        if (!a instanceof Function)
+          throw new Error("handler must be a function");
+        this._fns[D] = a;
+      }, C.prototype._fns = {
+        "member-child-identifier": function(D, a) {
+          var f = D.expression.value, b = a.value;
+          if (b instanceof Object && f in b)
+            return [{ value: b[f], path: a.path.concat(f) }];
+        },
+        "member-descendant-identifier": E(function(D, a, f) {
+          return D == f;
+        }),
+        "subscript-child-numeric_literal": d(function(D, a, f) {
+          return D === f;
+        }),
+        "member-child-numeric_literal": d(function(D, a, f) {
+          return String(D) === String(f);
+        }),
+        "subscript-descendant-numeric_literal": E(function(D, a, f) {
+          return D === f;
+        }),
+        "member-child-wildcard": d(function() {
+          return !0;
+        }),
+        "member-descendant-wildcard": E(function() {
+          return !0;
+        }),
+        "subscript-descendant-wildcard": E(function() {
+          return !0;
+        }),
+        "subscript-child-wildcard": d(function() {
+          return !0;
+        }),
+        "subscript-child-slice": function(D, a) {
+          if (p(a.value)) {
+            var f = D.expression.value.split(":").map(B), b = a.value.map(function(g, I) {
+              return { value: g, path: a.path.concat(I) };
+            });
+            return c.apply(null, [b].concat(f));
+          }
+        },
+        "subscript-child-union": function(D, a) {
+          var f = [];
+          return D.expression.value.forEach(function(b) {
+            var g = { operation: "subscript", scope: "child", expression: b.expression }, I = this.resolve(g), M = I(g, a);
+            M && (f = f.concat(M));
+          }, this), S(f);
+        },
+        "subscript-descendant-union": function(D, a, f) {
+          var b = n(".."), g = this, I = [], M = b.nodes(a, "$..*").slice(1);
+          return M.forEach(function(z) {
+            I.length >= f || D.expression.value.forEach(function(T) {
+              var N = { operation: "subscript", scope: "child", expression: T.expression }, U = g.resolve(N), q = U(N, z);
+              I = I.concat(q);
+            });
+          }), S(I);
+        },
+        "subscript-child-filter_expression": function(D, a, f) {
+          var b = D.expression.value.slice(2, -1), g = s.parse(b).body[0].expression, I = function(M, z) {
+            return u(g, { "@": z });
+          };
+          return this.descend(a, null, I, f);
+        },
+        "subscript-descendant-filter_expression": function(D, a, f) {
+          var b = D.expression.value.slice(2, -1), g = s.parse(b).body[0].expression, I = function(M, z) {
+            return u(g, { "@": z });
+          };
+          return this.traverse(a, null, I, f);
+        },
+        "subscript-child-script_expression": function(D, a) {
+          var f = D.expression.value.slice(1, -1);
+          return m(a, f, "$[{{value}}]");
+        },
+        "member-child-script_expression": function(D, a) {
+          var f = D.expression.value.slice(1, -1);
+          return m(a, f, "$.{{value}}");
+        },
+        "member-descendant-script_expression": function(D, a) {
+          var f = D.expression.value.slice(1, -1);
+          return m(a, f, "$..value");
+        }
+      }, C.prototype._fns["subscript-child-string_literal"] = C.prototype._fns["member-child-identifier"], C.prototype._fns["member-descendant-numeric_literal"] = C.prototype._fns["subscript-descendant-string_literal"] = C.prototype._fns["member-descendant-identifier"];
+      function m(D, a, f) {
+        var b = n("./index"), g = s.parse(a).body[0].expression, I = u(g, { "@": D.value }), M = f.replace(/\{\{\s*value\s*\}\}/g, I), z = b.nodes(D.value, M);
+        return z.forEach(function(T) {
+          T.path = D.path.concat(T.path.slice(1));
+        }), z;
+      }
+      function p(D) {
+        return Array.isArray(D);
+      }
+      function y(D) {
+        return D && !(D instanceof Array) && D instanceof Object;
+      }
+      function F(D) {
+        return function(a, f, b, g) {
+          var I = a.value, M = a.path, z = [], T = function(N, U) {
+            p(N) ? (N.forEach(function(q, V) {
+              z.length >= g || b(V, q, f) && z.push({ path: U.concat(V), value: q });
+            }), N.forEach(function(q, V) {
+              z.length >= g || D && T(q, U.concat(V));
+            })) : y(N) && (this.keys(N).forEach(function(q) {
+              z.length >= g || b(q, N[q], f) && z.push({ path: U.concat(q), value: N[q] });
+            }), this.keys(N).forEach(function(q) {
+              z.length >= g || D && T(N[q], U.concat(q));
+            }));
+          }.bind(this);
+          return T(I, M), z;
+        };
+      }
+      function d(D) {
+        return function(a, f, b) {
+          return this.descend(f, a.expression.value, D, b);
+        };
+      }
+      function E(D) {
+        return function(a, f, b) {
+          return this.traverse(f, a.expression.value, D, b);
+        };
+      }
+      function u() {
+        try {
+          return x.apply(this, arguments);
+        } catch {
+        }
+      }
+      function S(D) {
+        return D = D.filter(function(a) {
+          return a;
+        }), v(
+          D,
+          function(a) {
+            return a.path.map(function(f) {
+              return String(f).replace("-", "--");
+            }).join("-");
+          }
+        );
+      }
+      function B(D) {
+        var a = String(D);
+        return a.match(/^-?[0-9]+$/) ? parseInt(a) : null;
+      }
+      o.exports = C;
+    }, { "..": "jsonpath", "./aesprim": "./aesprim", "./index": 5, "./slice": 7, "static-eval": 15, underscore: 12 }], 5: [function(n, o, h) {
+      var s = n("assert"), c = n("./dict"), x = n("./parser"), v = n("./handlers"), C = function() {
+        this.initialize.apply(this, arguments);
+      };
+      C.prototype.initialize = function() {
+        this.parser = new x(), this.handlers = new v();
+      }, C.prototype.parse = function(y) {
+        return s.ok(m(y), "we need a path"), this.parser.parse(y);
+      }, C.prototype.parent = function(y, F) {
+        s.ok(y instanceof Object, "obj needs to be an object"), s.ok(F, "we need a path");
+        var d = this.nodes(y, F)[0];
+        return d.path.pop(), this.value(y, d.path);
+      }, C.prototype.apply = function(y, F, d) {
+        s.ok(y instanceof Object, "obj needs to be an object"), s.ok(F, "we need a path"), s.equal(typeof d, "function", "fn needs to be function");
+        var E = this.nodes(y, F).sort(function(u, S) {
+          return S.path.length - u.path.length;
+        });
+        return E.forEach(function(u) {
+          var S = u.path.pop(), B = this.value(y, this.stringify(u.path)), D = u.value = d.call(y, B[S]);
+          B[S] = D;
+        }, this), E;
+      }, C.prototype.value = function(y, F, d) {
+        if (s.ok(y instanceof Object, "obj needs to be an object"), s.ok(F, "we need a path"), arguments.length >= 3) {
+          var E = this.nodes(y, F).shift();
+          if (!E)
+            return this._vivify(y, F, d);
+          var u = E.path.slice(-1).shift(), S = this.parent(y, this.stringify(E.path));
+          S[u] = d;
+        }
+        return this.query(y, this.stringify(F), 1).shift();
+      }, C.prototype._vivify = function(y, F, d) {
+        var E = this;
+        s.ok(y instanceof Object, "obj needs to be an object"), s.ok(F, "we need a path");
+        var u = this.parser.parse(F).map(function(B) {
+          return B.expression.value;
+        }), S = function(B, D) {
+          var a = B.pop(), f = E.value(y, B);
+          f || (S(B.concat(), typeof a == "string" ? {} : []), f = E.value(y, B)), f[a] = D;
+        };
+        return S(u, d), this.query(y, F)[0];
+      }, C.prototype.query = function(y, F, d) {
+        s.ok(y instanceof Object, "obj needs to be an object"), s.ok(m(F), "we need a path");
+        var E = this.nodes(y, F, d).map(function(u) {
+          return u.value;
+        });
+        return E;
+      }, C.prototype.paths = function(y, F, d) {
+        s.ok(y instanceof Object, "obj needs to be an object"), s.ok(F, "we need a path");
+        var E = this.nodes(y, F, d).map(function(u) {
+          return u.path;
+        });
+        return E;
+      }, C.prototype.nodes = function(y, F, d) {
+        if (s.ok(y instanceof Object, "obj needs to be an object"), s.ok(F, "we need a path"), d === 0)
+          return [];
+        var E = this.parser.parse(F), u = this.handlers, S = [{ path: ["$"], value: y }], B = [];
+        return E.length && E[0].expression.type == "root" && E.shift(), E.length ? (E.forEach(function(D, a) {
+          if (!(B.length >= d)) {
+            var f = u.resolve(D), b = [];
+            S.forEach(function(g) {
+              if (!(B.length >= d)) {
+                var I = f(D, g, d);
+                a == E.length - 1 ? B = B.concat(I || []) : b = b.concat(I || []);
+              }
+            }), S = b;
+          }
+        }), d ? B.slice(0, d) : B) : S;
+      }, C.prototype.stringify = function(y) {
+        s.ok(y, "we need a path");
+        var F = "$", d = {
+          "descendant-member": "..{{value}}",
+          "child-member": ".{{value}}",
+          "descendant-subscript": "..[{{value}}]",
+          "child-subscript": "[{{value}}]"
+        };
+        return y = this._normalize(y), y.forEach(function(E) {
+          if (E.expression.type != "root") {
+            var u = [E.scope, E.operation].join("-"), S = d[u], B;
+            if (E.expression.type == "string_literal" ? B = JSON.stringify(E.expression.value) : B = E.expression.value, !S)
+              throw new Error("couldn't find template " + u);
+            F += S.replace(/{{value}}/, B);
+          }
+        }), F;
+      }, C.prototype._normalize = function(y) {
+        if (s.ok(y, "we need a path"), typeof y == "string")
+          return this.parser.parse(y);
+        if (Array.isArray(y) && typeof y[0] == "string") {
+          var F = [{ expression: { type: "root", value: "$" } }];
+          return y.forEach(function(d, E) {
+            if (!(d == "$" && E === 0))
+              if (typeof d == "string" && d.match("^" + c.identifier + "$"))
+                F.push({
+                  operation: "member",
+                  scope: "child",
+                  expression: { value: d, type: "identifier" }
+                });
+              else {
+                var u = typeof d == "number" ? "numeric_literal" : "string_literal";
+                F.push({
+                  operation: "subscript",
+                  scope: "child",
+                  expression: { value: d, type: u }
+                });
+              }
+          }), F;
+        } else if (Array.isArray(y) && typeof y[0] == "object")
+          return y;
+        throw new Error("couldn't understand path " + y);
+      };
+      function m(y) {
+        return Object.prototype.toString.call(y) == "[object String]";
+      }
+      C.Handlers = v, C.Parser = x;
+      var p = new C();
+      p.JSONPath = C, o.exports = p;
+    }, { "./dict": 2, "./handlers": 4, "./parser": 6, assert: 8 }], 6: [function(n, o, h) {
+      var s = n("./grammar"), c = n("../generated/parser"), x = function() {
+        var v = new c.Parser(), C = v.parseError;
+        return v.yy.parseError = function() {
+          v.yy.ast && v.yy.ast.initialize(), C.apply(v, arguments);
+        }, v;
+      };
+      x.grammar = s, o.exports = x;
+    }, { "../generated/parser": 1, "./grammar": 3 }], 7: [function(n, o, h) {
+      o.exports = function(c, x, v, C) {
+        if (typeof x == "string")
+          throw new Error("start cannot be a string");
+        if (typeof v == "string")
+          throw new Error("end cannot be a string");
+        if (typeof C == "string")
+          throw new Error("step cannot be a string");
+        var m = c.length;
+        if (C === 0)
+          throw new Error("step cannot be zero");
+        if (C = C ? s(C) : 1, x = x < 0 ? m + x : x, v = v < 0 ? m + v : v, x = s(x === 0 ? 0 : x || (C > 0 ? 0 : m - 1)), v = s(v === 0 ? 0 : v || (C > 0 ? m : -1)), x = C > 0 ? Math.max(0, x) : Math.min(m, x), v = C > 0 ? Math.min(v, m) : Math.max(-1, v), C > 0 && v <= x)
+          return [];
+        if (C < 0 && x <= v)
+          return [];
+        for (var p = [], y = x; y != v && !(C < 0 && y <= v || C > 0 && y >= v); y += C)
+          p.push(c[y]);
+        return p;
+      };
+      function s(c) {
+        return String(c).match(/^[0-9]+$/) ? parseInt(c) : Number.isFinite(c) ? parseInt(c, 10) : 0;
+      }
+    }, {}], 8: [function(n, o, h) {
+      var s = n("util/"), c = Array.prototype.slice, x = Object.prototype.hasOwnProperty, v = o.exports = F;
+      v.AssertionError = function(f) {
+        this.name = "AssertionError", this.actual = f.actual, this.expected = f.expected, this.operator = f.operator, f.message ? (this.message = f.message, this.generatedMessage = !1) : (this.message = p(this), this.generatedMessage = !0);
+        var b = f.stackStartFunction || y;
+        if (Error.captureStackTrace)
+          Error.captureStackTrace(this, b);
+        else {
+          var g = new Error();
+          if (g.stack) {
+            var I = g.stack, M = b.name, z = I.indexOf(`
+` + M);
+            if (z >= 0) {
+              var T = I.indexOf(`
+`, z + 1);
+              I = I.substring(T + 1);
+            }
+            this.stack = I;
+          }
+        }
+      }, s.inherits(v.AssertionError, Error);
+      function C(a, f) {
+        return s.isUndefined(f) ? "" + f : s.isNumber(f) && !isFinite(f) || s.isFunction(f) || s.isRegExp(f) ? f.toString() : f;
+      }
+      function m(a, f) {
+        return s.isString(a) ? a.length < f ? a : a.slice(0, f) : a;
+      }
+      function p(a) {
+        return m(JSON.stringify(a.actual, C), 128) + " " + a.operator + " " + m(JSON.stringify(a.expected, C), 128);
+      }
+      function y(a, f, b, g, I) {
+        throw new v.AssertionError({
+          message: b,
+          actual: a,
+          expected: f,
+          operator: g,
+          stackStartFunction: I
+        });
+      }
+      v.fail = y;
+      function F(a, f) {
+        a || y(a, !0, f, "==", v.ok);
+      }
+      v.ok = F, v.equal = function(f, b, g) {
+        f != b && y(f, b, g, "==", v.equal);
+      }, v.notEqual = function(f, b, g) {
+        f == b && y(f, b, g, "!=", v.notEqual);
+      }, v.deepEqual = function(f, b, g) {
+        d(f, b) || y(f, b, g, "deepEqual", v.deepEqual);
+      };
+      function d(a, f) {
+        if (a === f)
+          return !0;
+        if (s.isBuffer(a) && s.isBuffer(f)) {
+          if (a.length != f.length)
+            return !1;
+          for (var b = 0; b < a.length; b++)
+            if (a[b] !== f[b])
+              return !1;
+          return !0;
+        } else
+          return s.isDate(a) && s.isDate(f) ? a.getTime() === f.getTime() : s.isRegExp(a) && s.isRegExp(f) ? a.source === f.source && a.global === f.global && a.multiline === f.multiline && a.lastIndex === f.lastIndex && a.ignoreCase === f.ignoreCase : !s.isObject(a) && !s.isObject(f) ? a == f : u(a, f);
+      }
+      function E(a) {
+        return Object.prototype.toString.call(a) == "[object Arguments]";
+      }
+      function u(a, f) {
+        if (s.isNullOrUndefined(a) || s.isNullOrUndefined(f) || a.prototype !== f.prototype)
+          return !1;
+        if (s.isPrimitive(a) || s.isPrimitive(f))
+          return a === f;
+        var b = E(a), g = E(f);
+        if (b && !g || !b && g)
+          return !1;
+        if (b)
+          return a = c.call(a), f = c.call(f), d(a, f);
+        var I = D(a), M = D(f), z, T;
+        if (I.length != M.length)
+          return !1;
+        for (I.sort(), M.sort(), T = I.length - 1; T >= 0; T--)
+          if (I[T] != M[T])
+            return !1;
+        for (T = I.length - 1; T >= 0; T--)
+          if (z = I[T], !d(a[z], f[z]))
+            return !1;
+        return !0;
+      }
+      v.notDeepEqual = function(f, b, g) {
+        d(f, b) && y(f, b, g, "notDeepEqual", v.notDeepEqual);
+      }, v.strictEqual = function(f, b, g) {
+        f !== b && y(f, b, g, "===", v.strictEqual);
+      }, v.notStrictEqual = function(f, b, g) {
+        f === b && y(f, b, g, "!==", v.notStrictEqual);
+      };
+      function S(a, f) {
+        return !a || !f ? !1 : Object.prototype.toString.call(f) == "[object RegExp]" ? f.test(a) : a instanceof f ? !0 : f.call({}, a) === !0;
+      }
+      function B(a, f, b, g) {
+        var I;
+        s.isString(b) && (g = b, b = null);
+        try {
+          f();
+        } catch (M) {
+          I = M;
+        }
+        if (g = (b && b.name ? " (" + b.name + ")." : ".") + (g ? " " + g : "."), a && !I && y(I, b, "Missing expected exception" + g), !a && S(I, b) && y(I, b, "Got unwanted exception" + g), a && I && b && !S(I, b) || !a && I)
+          throw I;
+      }
+      v.throws = function(a, f, b) {
+        B.apply(this, [!0].concat(c.call(arguments)));
+      }, v.doesNotThrow = function(a, f) {
+        B.apply(this, [!1].concat(c.call(arguments)));
+      }, v.ifError = function(a) {
+        if (a)
+          throw a;
+      };
+      var D = Object.keys || function(a) {
+        var f = [];
+        for (var b in a)
+          x.call(a, b) && f.push(b);
+        return f;
+      };
+    }, { "util/": 11 }], 9: [function(n, o, h) {
+      typeof Object.create == "function" ? o.exports = function(c, x) {
+        c.super_ = x, c.prototype = Object.create(x.prototype, {
+          constructor: {
+            value: c,
+            enumerable: !1,
+            writable: !0,
+            configurable: !0
+          }
+        });
+      } : o.exports = function(c, x) {
+        c.super_ = x;
+        var v = function() {
+        };
+        v.prototype = x.prototype, c.prototype = new v(), c.prototype.constructor = c;
+      };
+    }, {}], 10: [function(n, o, h) {
+      o.exports = function(c) {
+        return c && typeof c == "object" && typeof c.copy == "function" && typeof c.fill == "function" && typeof c.readUInt8 == "function";
+      };
+    }, {}], 11: [function(n, o, h) {
+      (function(s, c) {
+        var x = /%[sdj%]/g;
+        h.format = function(_) {
+          if (!M(_)) {
+            for (var w = [], P = 0; P < arguments.length; P++)
+              w.push(m(arguments[P]));
+            return w.join(" ");
+          }
+          for (var P = 1, Q = arguments, ie = Q.length, G = String(_).replace(x, function(Z) {
+            if (Z === "%%")
+              return "%";
+            if (P >= ie)
+              return Z;
+            switch (Z) {
+              case "%s":
+                return String(Q[P++]);
+              case "%d":
+                return Number(Q[P++]);
+              case "%j":
+                try {
+                  return JSON.stringify(Q[P++]);
+                } catch {
+                  return "[Circular]";
+                }
+              default:
+                return Z;
+            }
+          }), K = Q[P]; P < ie; K = Q[++P])
+            b(K) || !U(K) ? G += " " + K : G += " " + m(K);
+          return G;
+        }, h.deprecate = function(_, w) {
+          if (T(c.process))
+            return function() {
+              return h.deprecate(_, w).apply(this, arguments);
+            };
+          if (s.noDeprecation === !0)
+            return _;
+          var P = !1;
+          function Q() {
+            if (!P) {
+              if (s.throwDeprecation)
+                throw new Error(w);
+              s.traceDeprecation ? console.trace(w) : console.error(w), P = !0;
+            }
+            return _.apply(this, arguments);
+          }
+          return Q;
+        };
+        var v = {}, C;
+        h.debuglog = function(_) {
+          if (T(C) && (C = s.env.NODE_DEBUG || ""), _ = _.toUpperCase(), !v[_])
+            if (new RegExp("\\b" + _ + "\\b", "i").test(C)) {
+              var w = s.pid;
+              v[_] = function() {
+                var P = h.format.apply(h, arguments);
+                console.error("%s %d: %s", _, w, P);
+              };
+            } else
+              v[_] = function() {
+              };
+          return v[_];
+        };
+        function m(_, w) {
+          var P = {
+            seen: [],
+            stylize: y
+          };
+          return arguments.length >= 3 && (P.depth = arguments[2]), arguments.length >= 4 && (P.colors = arguments[3]), f(w) ? P.showHidden = w : w && h._extend(P, w), T(P.showHidden) && (P.showHidden = !1), T(P.depth) && (P.depth = 2), T(P.colors) && (P.colors = !1), T(P.customInspect) && (P.customInspect = !0), P.colors && (P.stylize = p), d(P, _, P.depth);
+        }
+        h.inspect = m, m.colors = {
+          bold: [1, 22],
+          italic: [3, 23],
+          underline: [4, 24],
+          inverse: [7, 27],
+          white: [37, 39],
+          grey: [90, 39],
+          black: [30, 39],
+          blue: [34, 39],
+          cyan: [36, 39],
+          green: [32, 39],
+          magenta: [35, 39],
+          red: [31, 39],
+          yellow: [33, 39]
+        }, m.styles = {
+          special: "cyan",
+          number: "yellow",
+          boolean: "yellow",
+          undefined: "grey",
+          null: "bold",
+          string: "green",
+          date: "magenta",
+          // "name": intentionally not styling
+          regexp: "red"
+        };
+        function p(_, w) {
+          var P = m.styles[w];
+          return P ? "\x1B[" + m.colors[P][0] + "m" + _ + "\x1B[" + m.colors[P][1] + "m" : _;
+        }
+        function y(_, w) {
+          return _;
+        }
+        function F(_) {
+          var w = {};
+          return _.forEach(function(P, Q) {
+            w[P] = !0;
+          }), w;
+        }
+        function d(_, w, P) {
+          if (_.customInspect && w && fe(w.inspect) && // Filter out the util module, it's inspect function is special
+          w.inspect !== h.inspect && // Also filter out any prototype objects using the circular check.
+          !(w.constructor && w.constructor.prototype === w)) {
+            var Q = w.inspect(P, _);
+            return M(Q) || (Q = d(_, Q, P)), Q;
+          }
+          var ie = E(_, w);
+          if (ie)
+            return ie;
+          var G = Object.keys(w), K = F(G);
+          if (_.showHidden && (G = Object.getOwnPropertyNames(w)), V(w) && (G.indexOf("message") >= 0 || G.indexOf("description") >= 0))
+            return u(w);
+          if (G.length === 0) {
+            if (fe(w)) {
+              var Z = w.name ? ": " + w.name : "";
+              return _.stylize("[Function" + Z + "]", "special");
+            }
+            if (N(w))
+              return _.stylize(RegExp.prototype.toString.call(w), "regexp");
+            if (q(w))
+              return _.stylize(Date.prototype.toString.call(w), "date");
+            if (V(w))
+              return u(w);
+          }
+          var te = "", Ee = !1, De = ["{", "}"];
+          if (a(w) && (Ee = !0, De = ["[", "]"]), fe(w)) {
+            var $e = w.name ? ": " + w.name : "";
+            te = " [Function" + $e + "]";
+          }
+          if (N(w) && (te = " " + RegExp.prototype.toString.call(w)), q(w) && (te = " " + Date.prototype.toUTCString.call(w)), V(w) && (te = " " + u(w)), G.length === 0 && (!Ee || w.length == 0))
+            return De[0] + te + De[1];
+          if (P < 0)
+            return N(w) ? _.stylize(RegExp.prototype.toString.call(w), "regexp") : _.stylize("[Object]", "special");
+          _.seen.push(w);
+          var we;
+          return Ee ? we = S(_, w, P, K, G) : we = G.map(function(Re) {
+            return B(_, w, P, K, Re, Ee);
+          }), _.seen.pop(), D(we, te, De);
+        }
+        function E(_, w) {
+          if (T(w))
+            return _.stylize("undefined", "undefined");
+          if (M(w)) {
+            var P = "'" + JSON.stringify(w).replace(/^"|"$/g, "").replace(/'/g, "\\'").replace(/\\"/g, '"') + "'";
+            return _.stylize(P, "string");
+          }
+          if (I(w))
+            return _.stylize("" + w, "number");
+          if (f(w))
+            return _.stylize("" + w, "boolean");
+          if (b(w))
+            return _.stylize("null", "null");
+        }
+        function u(_) {
+          return "[" + Error.prototype.toString.call(_) + "]";
+        }
+        function S(_, w, P, Q, ie) {
+          for (var G = [], K = 0, Z = w.length; K < Z; ++K)
+            Ne(w, String(K)) ? G.push(B(
+              _,
+              w,
+              P,
+              Q,
+              String(K),
+              !0
+            )) : G.push("");
+          return ie.forEach(function(te) {
+            te.match(/^\d+$/) || G.push(B(
+              _,
+              w,
+              P,
+              Q,
+              te,
+              !0
+            ));
+          }), G;
+        }
+        function B(_, w, P, Q, ie, G) {
+          var K, Z, te;
+          if (te = Object.getOwnPropertyDescriptor(w, ie) || { value: w[ie] }, te.get ? te.set ? Z = _.stylize("[Getter/Setter]", "special") : Z = _.stylize("[Getter]", "special") : te.set && (Z = _.stylize("[Setter]", "special")), Ne(Q, ie) || (K = "[" + ie + "]"), Z || (_.seen.indexOf(te.value) < 0 ? (b(P) ? Z = d(_, te.value, null) : Z = d(_, te.value, P - 1), Z.indexOf(`
+`) > -1 && (G ? Z = Z.split(`
+`).map(function(Ee) {
+            return "  " + Ee;
+          }).join(`
+`).substr(2) : Z = `
+` + Z.split(`
+`).map(function(Ee) {
+            return "   " + Ee;
+          }).join(`
+`))) : Z = _.stylize("[Circular]", "special")), T(K)) {
+            if (G && ie.match(/^\d+$/))
+              return Z;
+            K = JSON.stringify("" + ie), K.match(/^"([a-zA-Z_][a-zA-Z_0-9]*)"$/) ? (K = K.substr(1, K.length - 2), K = _.stylize(K, "name")) : (K = K.replace(/'/g, "\\'").replace(/\\"/g, '"').replace(/(^"|"$)/g, "'"), K = _.stylize(K, "string"));
+          }
+          return K + ": " + Z;
+        }
+        function D(_, w, P) {
+          var Q = _.reduce(function(ie, G) {
+            return G.indexOf(`
+`) >= 0, ie + G.replace(/\u001b\[\d\d?m/g, "").length + 1;
+          }, 0);
+          return Q > 60 ? P[0] + (w === "" ? "" : w + `
+ `) + " " + _.join(`,
+  `) + " " + P[1] : P[0] + w + " " + _.join(", ") + " " + P[1];
+        }
+        function a(_) {
+          return Array.isArray(_);
+        }
+        h.isArray = a;
+        function f(_) {
+          return typeof _ == "boolean";
+        }
+        h.isBoolean = f;
+        function b(_) {
+          return _ === null;
+        }
+        h.isNull = b;
+        function g(_) {
+          return _ == null;
+        }
+        h.isNullOrUndefined = g;
+        function I(_) {
+          return typeof _ == "number";
+        }
+        h.isNumber = I;
+        function M(_) {
+          return typeof _ == "string";
+        }
+        h.isString = M;
+        function z(_) {
+          return typeof _ == "symbol";
+        }
+        h.isSymbol = z;
+        function T(_) {
+          return _ === void 0;
+        }
+        h.isUndefined = T;
+        function N(_) {
+          return U(_) && ee(_) === "[object RegExp]";
+        }
+        h.isRegExp = N;
+        function U(_) {
+          return typeof _ == "object" && _ !== null;
+        }
+        h.isObject = U;
+        function q(_) {
+          return U(_) && ee(_) === "[object Date]";
+        }
+        h.isDate = q;
+        function V(_) {
+          return U(_) && (ee(_) === "[object Error]" || _ instanceof Error);
+        }
+        h.isError = V;
+        function fe(_) {
+          return typeof _ == "function";
+        }
+        h.isFunction = fe;
+        function re(_) {
+          return _ === null || typeof _ == "boolean" || typeof _ == "number" || typeof _ == "string" || typeof _ == "symbol" || // ES6 symbol
+          typeof _ > "u";
+        }
+        h.isPrimitive = re, h.isBuffer = n("./support/isBuffer");
+        function ee(_) {
+          return Object.prototype.toString.call(_);
+        }
+        function pe(_) {
+          return _ < 10 ? "0" + _.toString(10) : _.toString(10);
+        }
+        var ce = [
+          "Jan",
+          "Feb",
+          "Mar",
+          "Apr",
+          "May",
+          "Jun",
+          "Jul",
+          "Aug",
+          "Sep",
+          "Oct",
+          "Nov",
+          "Dec"
+        ];
+        function he() {
+          var _ = new Date(), w = [
+            pe(_.getHours()),
+            pe(_.getMinutes()),
+            pe(_.getSeconds())
+          ].join(":");
+          return [_.getDate(), ce[_.getMonth()], w].join(" ");
+        }
+        h.log = function() {
+          console.log("%s - %s", he(), h.format.apply(h, arguments));
+        }, h.inherits = n("inherits"), h._extend = function(_, w) {
+          if (!w || !U(w))
+            return _;
+          for (var P = Object.keys(w), Q = P.length; Q--; )
+            _[P[Q]] = w[P[Q]];
+          return _;
+        };
+        function Ne(_, w) {
+          return Object.prototype.hasOwnProperty.call(_, w);
+        }
+      }).call(this, n("_process"), typeof pt < "u" ? pt : typeof self < "u" ? self : typeof window < "u" ? window : {});
+    }, { "./support/isBuffer": 10, _process: 14, inherits: 9 }], 12: [function(n, o, h) {
+    }, {}], 13: [function(n, o, h) {
+      (function(s) {
+        function c(m, p) {
+          for (var y = 0, F = m.length - 1; F >= 0; F--) {
+            var d = m[F];
+            d === "." ? m.splice(F, 1) : d === ".." ? (m.splice(F, 1), y++) : y && (m.splice(F, 1), y--);
+          }
+          if (p)
+            for (; y--; y)
+              m.unshift("..");
+          return m;
+        }
+        h.resolve = function() {
+          for (var m = "", p = !1, y = arguments.length - 1; y >= -1 && !p; y--) {
+            var F = y >= 0 ? arguments[y] : s.cwd();
+            if (typeof F != "string")
+              throw new TypeError("Arguments to path.resolve must be strings");
+            if (!F)
+              continue;
+            m = F + "/" + m, p = F.charAt(0) === "/";
+          }
+          return m = c(v(m.split("/"), function(d) {
+            return !!d;
+          }), !p).join("/"), (p ? "/" : "") + m || ".";
+        }, h.normalize = function(m) {
+          var p = h.isAbsolute(m), y = C(m, -1) === "/";
+          return m = c(v(m.split("/"), function(F) {
+            return !!F;
+          }), !p).join("/"), !m && !p && (m = "."), m && y && (m += "/"), (p ? "/" : "") + m;
+        }, h.isAbsolute = function(m) {
+          return m.charAt(0) === "/";
+        }, h.join = function() {
+          var m = Array.prototype.slice.call(arguments, 0);
+          return h.normalize(v(m, function(p, y) {
+            if (typeof p != "string")
+              throw new TypeError("Arguments to path.join must be strings");
+            return p;
+          }).join("/"));
+        }, h.relative = function(m, p) {
+          m = h.resolve(m).substr(1), p = h.resolve(p).substr(1);
+          function y(D) {
+            for (var a = 0; a < D.length && D[a] === ""; a++)
+              ;
+            for (var f = D.length - 1; f >= 0 && D[f] === ""; f--)
+              ;
+            return a > f ? [] : D.slice(a, f - a + 1);
+          }
+          for (var F = y(m.split("/")), d = y(p.split("/")), E = Math.min(F.length, d.length), u = E, S = 0; S < E; S++)
+            if (F[S] !== d[S]) {
+              u = S;
+              break;
+            }
+          for (var B = [], S = u; S < F.length; S++)
+            B.push("..");
+          return B = B.concat(d.slice(u)), B.join("/");
+        }, h.sep = "/", h.delimiter = ":", h.dirname = function(m) {
+          if (typeof m != "string" && (m = m + ""), m.length === 0)
+            return ".";
+          for (var p = m.charCodeAt(0), y = p === 47, F = -1, d = !0, E = m.length - 1; E >= 1; --E)
+            if (p = m.charCodeAt(E), p === 47) {
+              if (!d) {
+                F = E;
+                break;
+              }
+            } else
+              d = !1;
+          return F === -1 ? y ? "/" : "." : y && F === 1 ? "/" : m.slice(0, F);
+        };
+        function x(m) {
+          typeof m != "string" && (m = m + "");
+          var p = 0, y = -1, F = !0, d;
+          for (d = m.length - 1; d >= 0; --d)
+            if (m.charCodeAt(d) === 47) {
+              if (!F) {
+                p = d + 1;
+                break;
+              }
+            } else
+              y === -1 && (F = !1, y = d + 1);
+          return y === -1 ? "" : m.slice(p, y);
+        }
+        h.basename = function(m, p) {
+          var y = x(m);
+          return p && y.substr(-1 * p.length) === p && (y = y.substr(0, y.length - p.length)), y;
+        }, h.extname = function(m) {
+          typeof m != "string" && (m = m + "");
+          for (var p = -1, y = 0, F = -1, d = !0, E = 0, u = m.length - 1; u >= 0; --u) {
+            var S = m.charCodeAt(u);
+            if (S === 47) {
+              if (!d) {
+                y = u + 1;
+                break;
+              }
+              continue;
+            }
+            F === -1 && (d = !1, F = u + 1), S === 46 ? p === -1 ? p = u : E !== 1 && (E = 1) : p !== -1 && (E = -1);
+          }
+          return p === -1 || F === -1 || // We saw a non-dot character immediately before the dot
+          E === 0 || // The (right-most) trimmed path component is exactly '..'
+          E === 1 && p === F - 1 && p === y + 1 ? "" : m.slice(p, F);
+        };
+        function v(m, p) {
+          if (m.filter)
+            return m.filter(p);
+          for (var y = [], F = 0; F < m.length; F++)
+            p(m[F], F, m) && y.push(m[F]);
+          return y;
+        }
+        var C = "ab".substr(-1) === "b" ? function(m, p, y) {
+          return m.substr(p, y);
+        } : function(m, p, y) {
+          return p < 0 && (p = m.length + p), m.substr(p, y);
+        };
+      }).call(this, n("_process"));
+    }, { _process: 14 }], 14: [function(n, o, h) {
+      var s = o.exports = {}, c, x;
+      function v() {
+        throw new Error("setTimeout has not been defined");
+      }
+      function C() {
+        throw new Error("clearTimeout has not been defined");
+      }
+      (function() {
+        try {
+          typeof setTimeout == "function" ? c = setTimeout : c = v;
+        } catch {
+          c = v;
+        }
+        try {
+          typeof clearTimeout == "function" ? x = clearTimeout : x = C;
+        } catch {
+          x = C;
+        }
+      })();
+      function m(a) {
+        if (c === setTimeout)
+          return setTimeout(a, 0);
+        if ((c === v || !c) && setTimeout)
+          return c = setTimeout, setTimeout(a, 0);
+        try {
+          return c(a, 0);
+        } catch {
+          try {
+            return c.call(null, a, 0);
+          } catch {
+            return c.call(this, a, 0);
+          }
+        }
+      }
+      function p(a) {
+        if (x === clearTimeout)
+          return clearTimeout(a);
+        if ((x === C || !x) && clearTimeout)
+          return x = clearTimeout, clearTimeout(a);
+        try {
+          return x(a);
+        } catch {
+          try {
+            return x.call(null, a);
+          } catch {
+            return x.call(this, a);
+          }
+        }
+      }
+      var y = [], F = !1, d, E = -1;
+      function u() {
+        !F || !d || (F = !1, d.length ? y = d.concat(y) : E = -1, y.length && S());
+      }
+      function S() {
+        if (!F) {
+          var a = m(u);
+          F = !0;
+          for (var f = y.length; f; ) {
+            for (d = y, y = []; ++E < f; )
+              d && d[E].run();
+            E = -1, f = y.length;
+          }
+          d = null, F = !1, p(a);
+        }
+      }
+      s.nextTick = function(a) {
+        var f = new Array(arguments.length - 1);
+        if (arguments.length > 1)
+          for (var b = 1; b < arguments.length; b++)
+            f[b - 1] = arguments[b];
+        y.push(new B(a, f)), y.length === 1 && !F && m(S);
+      };
+      function B(a, f) {
+        this.fun = a, this.array = f;
+      }
+      B.prototype.run = function() {
+        this.fun.apply(null, this.array);
+      }, s.title = "browser", s.browser = !0, s.env = {}, s.argv = [], s.version = "", s.versions = {};
+      function D() {
+      }
+      s.on = D, s.addListener = D, s.once = D, s.off = D, s.removeListener = D, s.removeAllListeners = D, s.emit = D, s.prependListener = D, s.prependOnceListener = D, s.listeners = function(a) {
+        return [];
+      }, s.binding = function(a) {
+        throw new Error("process.binding is not supported");
+      }, s.cwd = function() {
+        return "/";
+      }, s.chdir = function(a) {
+        throw new Error("process.chdir is not supported");
+      }, s.umask = function() {
+        return 0;
+      };
+    }, {}], 15: [function(n, o, h) {
+      var s = n("escodegen").generate;
+      o.exports = function(c, x) {
+        x || (x = {});
+        var v = {}, C = function m(p, y) {
+          if (p.type === "Literal")
+            return p.value;
+          if (p.type === "UnaryExpression") {
+            var F = m(p.argument);
+            return p.operator === "+" ? +F : p.operator === "-" ? -F : p.operator === "~" ? ~F : p.operator === "!" ? !F : v;
+          } else if (p.type === "ArrayExpression") {
+            for (var d = [], E = 0, u = p.elements.length; E < u; E++) {
+              var S = m(p.elements[E]);
+              if (S === v)
+                return v;
+              d.push(S);
+            }
+            return d;
+          } else if (p.type === "ObjectExpression") {
+            for (var B = {}, E = 0; E < p.properties.length; E++) {
+              var D = p.properties[E], a = D.value === null ? D.value : m(D.value);
+              if (a === v)
+                return v;
+              B[D.key.value || D.key.name] = a;
+            }
+            return B;
+          } else if (p.type === "BinaryExpression" || p.type === "LogicalExpression") {
+            var u = m(p.left);
+            if (u === v)
+              return v;
+            var f = m(p.right);
+            if (f === v)
+              return v;
+            var b = p.operator;
+            return b === "==" ? u == f : b === "===" ? u === f : b === "!=" ? u != f : b === "!==" ? u !== f : b === "+" ? u + f : b === "-" ? u - f : b === "*" ? u * f : b === "/" ? u / f : b === "%" ? u % f : b === "<" ? u < f : b === "<=" ? u <= f : b === ">" ? u > f : b === ">=" ? u >= f : b === "|" ? u | f : b === "&" ? u & f : b === "^" ? u ^ f : b === "&&" ? u && f : b === "||" ? u || f : v;
+          } else {
+            if (p.type === "Identifier")
+              return {}.hasOwnProperty.call(x, p.name) ? x[p.name] : v;
+            if (p.type === "ThisExpression")
+              return {}.hasOwnProperty.call(x, "this") ? x.this : v;
+            if (p.type === "CallExpression") {
+              var g = m(p.callee);
+              if (g === v || typeof g != "function")
+                return v;
+              var I = p.callee.object ? m(p.callee.object) : v;
+              I === v && (I = null);
+              for (var M = [], E = 0, u = p.arguments.length; E < u; E++) {
+                var S = m(p.arguments[E]);
+                if (S === v)
+                  return v;
+                M.push(S);
+              }
+              return g.apply(I, M);
+            } else if (p.type === "MemberExpression") {
+              var B = m(p.object);
+              if (B === v || typeof B == "function")
+                return v;
+              if (p.property.type === "Identifier")
+                return B[p.property.name];
+              var D = m(p.property);
+              return D === v ? v : B[D];
+            } else if (p.type === "ConditionalExpression") {
+              var F = m(p.test);
+              return F === v ? v : m(F ? p.consequent : p.alternate);
+            } else if (p.type === "ExpressionStatement") {
+              var F = m(p.expression);
+              return F === v ? v : F;
+            } else {
+              if (p.type === "ReturnStatement")
+                return m(p.argument);
+              if (p.type === "FunctionExpression") {
+                var z = p.body.body, T = {};
+                Object.keys(x).forEach(function(ce) {
+                  T[ce] = x[ce];
+                });
+                for (var E = 0; E < p.params.length; E++) {
+                  var N = p.params[E];
+                  if (N.type == "Identifier")
+                    x[N.name] = null;
+                  else
+                    return v;
+                }
+                for (var E in z)
+                  if (m(z[E]) === v)
+                    return v;
+                x = T;
+                var U = Object.keys(x), q = U.map(function(ce) {
+                  return x[ce];
+                });
+                return Function(U.join(", "), "return " + s(p)).apply(null, q);
+              } else if (p.type === "TemplateLiteral") {
+                for (var V = "", E = 0; E < p.expressions.length; E++)
+                  V += m(p.quasis[E]), V += m(p.expressions[E]);
+                return V += m(p.quasis[E]), V;
+              } else if (p.type === "TaggedTemplateExpression") {
+                var fe = m(p.tag), re = p.quasi, ee = re.quasis.map(m), pe = re.expressions.map(m);
+                return fe.apply(null, [ee].concat(pe));
+              } else
+                return p.type === "TemplateElement" ? p.value.cooked : v;
+            }
+          }
+        }(c);
+        return C === v ? void 0 : C;
+      };
+    }, { escodegen: 12 }], jsonpath: [function(n, o, h) {
+      o.exports = n("./lib/index");
+    }, { "./lib/index": 5 }] }, {}, ["jsonpath"])("jsonpath");
+  });
+})(ir);
+function ur(r, i, n) {
+  return i = Pe(i), pr(r, Ye() ? Reflect.construct(i, n || [], Pe(r).constructor) : i.apply(r, n));
+}
+function mt(r, i, n) {
+  if (Ye())
+    return Reflect.construct.apply(null, arguments);
+  var o = [null];
+  o.push.apply(o, i);
+  var h = new (r.bind.apply(r, o))();
+  return n && Te(h, n.prototype), h;
+}
+function Ye() {
+  try {
+    var r = !Boolean.prototype.valueOf.call(Reflect.construct(Boolean, [], function() {
+    }));
+  } catch {
+  }
+  return (Ye = function() {
+    return !!r;
+  })();
+}
+function ht(r, i) {
+  var n = Object.keys(r);
+  if (Object.getOwnPropertySymbols) {
+    var o = Object.getOwnPropertySymbols(r);
+    i && (o = o.filter(function(h) {
+      return Object.getOwnPropertyDescriptor(r, h).enumerable;
+    })), n.push.apply(n, o);
+  }
+  return n;
+}
+function ar(r) {
+  for (var i = 1; i < arguments.length; i++) {
+    var n = arguments[i] != null ? arguments[i] : {};
+    i % 2 ? ht(Object(n), !0).forEach(function(o) {
+      or(r, o, n[o]);
+    }) : Object.getOwnPropertyDescriptors ? Object.defineProperties(r, Object.getOwnPropertyDescriptors(n)) : ht(Object(n)).forEach(function(o) {
+      Object.defineProperty(r, o, Object.getOwnPropertyDescriptor(n, o));
+    });
+  }
+  return r;
+}
+function sr(r, i) {
+  if (typeof r != "object" || !r)
+    return r;
+  var n = r[Symbol.toPrimitive];
+  if (n !== void 0) {
+    var o = n.call(r, i || "default");
+    if (typeof o != "object")
+      return o;
+    throw new TypeError("@@toPrimitive must return a primitive value.");
+  }
+  return (i === "string" ? String : Number)(r);
+}
+function Et(r) {
+  var i = sr(r, "string");
+  return typeof i == "symbol" ? i : i + "";
+}
+function ye(r) {
+  return ye = typeof Symbol == "function" && typeof Symbol.iterator == "symbol" ? function(i) {
+    return typeof i;
+  } : function(i) {
+    return i && typeof Symbol == "function" && i.constructor === Symbol && i !== Symbol.prototype ? "symbol" : typeof i;
+  }, ye(r);
+}
+function ke(r, i) {
+  if (!(r instanceof i))
+    throw new TypeError("Cannot call a class as a function");
+}
+function yt(r, i) {
+  for (var n = 0; n < i.length; n++) {
+    var o = i[n];
+    o.enumerable = o.enumerable || !1, o.configurable = !0, "value" in o && (o.writable = !0), Object.defineProperty(r, Et(o.key), o);
+  }
+}
+function Be(r, i, n) {
+  return i && yt(r.prototype, i), n && yt(r, n), Object.defineProperty(r, "prototype", {
+    writable: !1
+  }), r;
+}
+function or(r, i, n) {
+  return i = Et(i), i in r ? Object.defineProperty(r, i, {
+    value: n,
+    enumerable: !0,
+    configurable: !0,
+    writable: !0
+  }) : r[i] = n, r;
+}
+function lr(r, i) {
+  if (typeof i != "function" && i !== null)
+    throw new TypeError("Super expression must either be null or a function");
+  r.prototype = Object.create(i && i.prototype, {
+    constructor: {
+      value: r,
+      writable: !0,
+      configurable: !0
+    }
+  }), Object.defineProperty(r, "prototype", {
+    writable: !1
+  }), i && Te(r, i);
+}
+function Pe(r) {
+  return Pe = Object.setPrototypeOf ? Object.getPrototypeOf.bind() : function(n) {
+    return n.__proto__ || Object.getPrototypeOf(n);
+  }, Pe(r);
+}
+function Te(r, i) {
+  return Te = Object.setPrototypeOf ? Object.setPrototypeOf.bind() : function(o, h) {
+    return o.__proto__ = h, o;
+  }, Te(r, i);
+}
+function cr(r) {
+  try {
+    return Function.toString.call(r).indexOf("[native code]") !== -1;
+  } catch {
+    return typeof r == "function";
+  }
+}
+function Ve(r) {
+  var i = typeof Map == "function" ? /* @__PURE__ */ new Map() : void 0;
+  return Ve = function(o) {
+    if (o === null || !cr(o))
+      return o;
+    if (typeof o != "function")
+      throw new TypeError("Super expression must either be null or a function");
+    if (typeof i < "u") {
+      if (i.has(o))
+        return i.get(o);
+      i.set(o, h);
+    }
+    function h() {
+      return mt(o, arguments, Pe(this).constructor);
+    }
+    return h.prototype = Object.create(o.prototype, {
+      constructor: {
+        value: h,
+        enumerable: !1,
+        writable: !0,
+        configurable: !0
+      }
+    }), Te(h, o);
+  }, Ve(r);
+}
+function fr(r) {
+  if (r === void 0)
+    throw new ReferenceError("this hasn't been initialised - super() hasn't been called");
+  return r;
+}
+function pr(r, i) {
+  if (i && (typeof i == "object" || typeof i == "function"))
+    return i;
+  if (i !== void 0)
+    throw new TypeError("Derived constructors may only return object or undefined");
+  return fr(r);
+}
+function Ze(r) {
+  return hr(r) || yr(r) || gt(r) || dr();
+}
+function hr(r) {
+  if (Array.isArray(r))
+    return Je(r);
+}
+function yr(r) {
+  if (typeof Symbol < "u" && r[Symbol.iterator] != null || r["@@iterator"] != null)
+    return Array.from(r);
+}
+function gt(r, i) {
+  if (r) {
+    if (typeof r == "string")
+      return Je(r, i);
+    var n = Object.prototype.toString.call(r).slice(8, -1);
+    if (n === "Object" && r.constructor && (n = r.constructor.name), n === "Map" || n === "Set")
+      return Array.from(r);
+    if (n === "Arguments" || /^(?:Ui|I)nt(?:8|16|32)(?:Clamped)?Array$/.test(n))
+      return Je(r, i);
+  }
+}
+function Je(r, i) {
+  (i == null || i > r.length) && (i = r.length);
+  for (var n = 0, o = new Array(i); n < i; n++)
+    o[n] = r[n];
+  return o;
+}
+function dr() {
+  throw new TypeError(`Invalid attempt to spread non-iterable instance.
+In order to be iterable, non-array objects must have a [Symbol.iterator]() method.`);
+}
+function mr(r, i) {
+  var n = typeof Symbol < "u" && r[Symbol.iterator] || r["@@iterator"];
+  if (!n) {
+    if (Array.isArray(r) || (n = gt(r)) || i && r && typeof r.length == "number") {
+      n && (r = n);
+      var o = 0, h = function() {
+      };
+      return {
+        s: h,
+        n: function() {
+          return o >= r.length ? {
+            done: !0
+          } : {
+            done: !1,
+            value: r[o++]
+          };
+        },
+        e: function(v) {
+          throw v;
+        },
+        f: h
+      };
+    }
+    throw new TypeError(`Invalid attempt to iterate non-iterable instance.
+In order to be iterable, non-array objects must have a [Symbol.iterator]() method.`);
+  }
+  var s = !0, c = !1, x;
+  return {
+    s: function() {
+      n = n.call(r);
+    },
+    n: function() {
+      var v = n.next();
+      return s = v.done, v;
+    },
+    e: function(v) {
+      c = !0, x = v;
+    },
+    f: function() {
+      try {
+        !s && n.return != null && n.return();
+      } finally {
+        if (c)
+          throw x;
+      }
+    }
+  };
+}
+var Er = /* @__PURE__ */ function() {
+  function r() {
+    ke(this, r);
+  }
+  return Be(r, [{
+    key: "add",
+    value: (
+      /**
+       * @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
+       */
+      function(n, o, h) {
+        if (typeof arguments[0] != "string")
+          for (var s in arguments[0])
+            this.add(s, arguments[0][s], arguments[1]);
+        else
+          (Array.isArray(n) ? n : [n]).forEach(function(c) {
+            this[c] = this[c] || [], o && this[c][h ? "unshift" : "push"](o);
+          }, 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
+     */
+  }, {
+    key: "run",
+    value: function(n, o) {
+      this[n] = this[n] || [], this[n].forEach(function(h) {
+        h.call(o && o.context ? o.context : o, o);
+      });
+    }
+  }]);
+}(), gr = /* @__PURE__ */ function() {
+  function r(i) {
+    ke(this, r), this.jsep = i, this.registered = {};
+  }
+  return Be(r, [{
+    key: "register",
+    value: function() {
+      for (var n = this, o = arguments.length, h = new Array(o), s = 0; s < o; s++)
+        h[s] = arguments[s];
+      h.forEach(function(c) {
+        if (ye(c) !== "object" || !c.name || !c.init)
+          throw new Error("Invalid JSEP plugin format");
+        n.registered[c.name] || (c.init(n.jsep), n.registered[c.name] = c);
+      });
+    }
+  }]);
+}(), de = /* @__PURE__ */ function() {
+  function r(i) {
+    ke(this, r), this.expr = i, this.index = 0;
+  }
+  return Be(r, [{
+    key: "char",
+    get: (
+      // ==================== END CONFIG ============================
+      /**
+       * @returns {string}
+       */
+      function() {
+        return this.expr.charAt(this.index);
+      }
+    )
+    /**
+     * @returns {number}
+     */
+  }, {
+    key: "code",
+    get: function() {
+      return this.expr.charCodeAt(this.index);
+    }
+  }, {
+    key: "throwError",
+    value: (
+      /**
+       * throw error at index of the expression
+       * @param {string} message
+       * @throws
+       */
+      function(n) {
+        var o = new Error(n + " at character " + this.index);
+        throw o.index = this.index, o.description = n, o;
+      }
+    )
+    /**
+     * Run a given hook
+     * @param {string} name
+     * @param {jsep.Expression|false} [node]
+     * @returns {?jsep.Expression}
+     */
+  }, {
+    key: "runHook",
+    value: function(n, o) {
+      if (r.hooks[n]) {
+        var h = {
+          context: this,
+          node: o
+        };
+        return r.hooks.run(n, h), h.node;
+      }
+      return o;
+    }
+    /**
+     * Runs a given hook until one returns a node
+     * @param {string} name
+     * @returns {?jsep.Expression}
+     */
+  }, {
+    key: "searchHook",
+    value: function(n) {
+      if (r.hooks[n]) {
+        var o = {
+          context: this
+        };
+        return r.hooks[n].find(function(h) {
+          return h.call(o.context, o), o.node;
+        }), o.node;
+      }
+    }
+    /**
+     * Push `index` up to the next non-space character
+     */
+  }, {
+    key: "gobbleSpaces",
+    value: function() {
+      for (var n = this.code; n === r.SPACE_CODE || n === r.TAB_CODE || n === r.LF_CODE || n === r.CR_CODE; )
+        n = 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}
+     */
+  }, {
+    key: "parse",
+    value: function() {
+      this.runHook("before-all");
+      var n = this.gobbleExpressions(), o = n.length === 1 ? n[0] : {
+        type: r.COMPOUND,
+        body: n
+      };
+      return this.runHook("after-all", o);
+    }
+    /**
+     * top-level parser (but can be reused within as well)
+     * @param {number} [untilICode]
+     * @returns {jsep.Expression[]}
+     */
+  }, {
+    key: "gobbleExpressions",
+    value: function(n) {
+      for (var o = [], h, s; this.index < this.expr.length; )
+        if (h = this.code, h === r.SEMCOL_CODE || h === r.COMMA_CODE)
+          this.index++;
+        else if (s = this.gobbleExpression())
+          o.push(s);
+        else if (this.index < this.expr.length) {
+          if (h === n)
+            break;
+          this.throwError('Unexpected "' + this.char + '"');
+        }
+      return o;
+    }
+    /**
+     * The main parsing function.
+     * @returns {?jsep.Expression}
+     */
+  }, {
+    key: "gobbleExpression",
+    value: function() {
+      var n = this.searchHook("gobble-expression") || this.gobbleBinaryExpression();
+      return this.gobbleSpaces(), this.runHook("after-expression", n);
+    }
+    /**
+     * 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}
+     */
+  }, {
+    key: "gobbleBinaryOp",
+    value: function() {
+      this.gobbleSpaces();
+      for (var n = this.expr.substr(this.index, r.max_binop_len), o = n.length; o > 0; ) {
+        if (r.binary_ops.hasOwnProperty(n) && (!r.isIdentifierStart(this.code) || this.index + n.length < this.expr.length && !r.isIdentifierPart(this.expr.charCodeAt(this.index + n.length))))
+          return this.index += o, n;
+        n = n.substr(0, --o);
+      }
+      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}
+     */
+  }, {
+    key: "gobbleBinaryExpression",
+    value: function() {
+      var n, o, h, s, c, x, v, C, m;
+      if (x = this.gobbleToken(), !x || (o = this.gobbleBinaryOp(), !o))
+        return x;
+      for (c = {
+        value: o,
+        prec: r.binaryPrecedence(o),
+        right_a: r.right_associative.has(o)
+      }, v = this.gobbleToken(), v || this.throwError("Expected expression after " + o), s = [x, c, v]; o = this.gobbleBinaryOp(); ) {
+        if (h = r.binaryPrecedence(o), h === 0) {
+          this.index -= o.length;
+          break;
+        }
+        c = {
+          value: o,
+          prec: h,
+          right_a: r.right_associative.has(o)
+        }, m = o;
+        for (var p = function(F) {
+          return c.right_a && F.right_a ? h > F.prec : h <= F.prec;
+        }; s.length > 2 && p(s[s.length - 2]); )
+          v = s.pop(), o = s.pop().value, x = s.pop(), n = {
+            type: r.BINARY_EXP,
+            operator: o,
+            left: x,
+            right: v
+          }, s.push(n);
+        n = this.gobbleToken(), n || this.throwError("Expected expression after " + m), s.push(c, n);
+      }
+      for (C = s.length - 1, n = s[C]; C > 1; )
+        n = {
+          type: r.BINARY_EXP,
+          operator: s[C - 1].value,
+          left: s[C - 2],
+          right: n
+        }, C -= 2;
+      return n;
+    }
+    /**
+     * 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}
+     */
+  }, {
+    key: "gobbleToken",
+    value: function() {
+      var n, o, h, s;
+      if (this.gobbleSpaces(), s = this.searchHook("gobble-token"), s)
+        return this.runHook("after-token", s);
+      if (n = this.code, r.isDecimalDigit(n) || n === r.PERIOD_CODE)
+        return this.gobbleNumericLiteral();
+      if (n === r.SQUOTE_CODE || n === r.DQUOTE_CODE)
+        s = this.gobbleStringLiteral();
+      else if (n === r.OBRACK_CODE)
+        s = this.gobbleArray();
+      else {
+        for (o = this.expr.substr(this.index, r.max_unop_len), h = o.length; h > 0; ) {
+          if (r.unary_ops.hasOwnProperty(o) && (!r.isIdentifierStart(this.code) || this.index + o.length < this.expr.length && !r.isIdentifierPart(this.expr.charCodeAt(this.index + o.length)))) {
+            this.index += h;
+            var c = this.gobbleToken();
+            return c || this.throwError("missing unaryOp argument"), this.runHook("after-token", {
+              type: r.UNARY_EXP,
+              operator: o,
+              argument: c,
+              prefix: !0
+            });
+          }
+          o = o.substr(0, --h);
+        }
+        r.isIdentifierStart(n) ? (s = this.gobbleIdentifier(), r.literals.hasOwnProperty(s.name) ? s = {
+          type: r.LITERAL,
+          value: r.literals[s.name],
+          raw: s.name
+        } : s.name === r.this_str && (s = {
+          type: r.THIS_EXP
+        })) : n === r.OPAREN_CODE && (s = this.gobbleGroup());
+      }
+      return s ? (s = this.gobbleTokenProperty(s), this.runHook("after-token", s)) : 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}
+     */
+  }, {
+    key: "gobbleTokenProperty",
+    value: function(n) {
+      this.gobbleSpaces();
+      for (var o = this.code; o === r.PERIOD_CODE || o === r.OBRACK_CODE || o === r.OPAREN_CODE || o === r.QUMARK_CODE; ) {
+        var h = void 0;
+        if (o === r.QUMARK_CODE) {
+          if (this.expr.charCodeAt(this.index + 1) !== r.PERIOD_CODE)
+            break;
+          h = !0, this.index += 2, this.gobbleSpaces(), o = this.code;
+        }
+        this.index++, o === r.OBRACK_CODE ? (n = {
+          type: r.MEMBER_EXP,
+          computed: !0,
+          object: n,
+          property: this.gobbleExpression()
+        }, this.gobbleSpaces(), o = this.code, o !== r.CBRACK_CODE && this.throwError("Unclosed ["), this.index++) : o === r.OPAREN_CODE ? n = {
+          type: r.CALL_EXP,
+          arguments: this.gobbleArguments(r.CPAREN_CODE),
+          callee: n
+        } : (o === r.PERIOD_CODE || h) && (h && this.index--, this.gobbleSpaces(), n = {
+          type: r.MEMBER_EXP,
+          computed: !1,
+          object: n,
+          property: this.gobbleIdentifier()
+        }), h && (n.optional = !0), this.gobbleSpaces(), o = this.code;
+      }
+      return n;
+    }
+    /**
+     * 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}
+     */
+  }, {
+    key: "gobbleNumericLiteral",
+    value: function() {
+      for (var n = "", o, h; r.isDecimalDigit(this.code); )
+        n += this.expr.charAt(this.index++);
+      if (this.code === r.PERIOD_CODE)
+        for (n += this.expr.charAt(this.index++); r.isDecimalDigit(this.code); )
+          n += this.expr.charAt(this.index++);
+      if (o = this.char, o === "e" || o === "E") {
+        for (n += this.expr.charAt(this.index++), o = this.char, (o === "+" || o === "-") && (n += this.expr.charAt(this.index++)); r.isDecimalDigit(this.code); )
+          n += this.expr.charAt(this.index++);
+        r.isDecimalDigit(this.expr.charCodeAt(this.index - 1)) || this.throwError("Expected exponent (" + n + this.char + ")");
+      }
+      return h = this.code, r.isIdentifierStart(h) ? this.throwError("Variable names cannot start with a number (" + n + this.char + ")") : (h === r.PERIOD_CODE || n.length === 1 && n.charCodeAt(0) === r.PERIOD_CODE) && this.throwError("Unexpected period"), {
+        type: r.LITERAL,
+        value: parseFloat(n),
+        raw: n
+      };
+    }
+    /**
+     * 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}
+     */
+  }, {
+    key: "gobbleStringLiteral",
+    value: function() {
+      for (var n = "", o = this.index, h = this.expr.charAt(this.index++), s = !1; this.index < this.expr.length; ) {
+        var c = this.expr.charAt(this.index++);
+        if (c === h) {
+          s = !0;
+          break;
+        } else if (c === "\\")
+          switch (c = this.expr.charAt(this.index++), c) {
+            case "n":
+              n += `
+`;
+              break;
+            case "r":
+              n += "\r";
+              break;
+            case "t":
+              n += "	";
+              break;
+            case "b":
+              n += "\b";
+              break;
+            case "f":
+              n += "\f";
+              break;
+            case "v":
+              n += "\v";
+              break;
+            default:
+              n += c;
+          }
+        else
+          n += c;
+      }
+      return s || this.throwError('Unclosed quote after "' + n + '"'), {
+        type: r.LITERAL,
+        value: n,
+        raw: this.expr.substring(o, 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}
+     */
+  }, {
+    key: "gobbleIdentifier",
+    value: function() {
+      var n = this.code, o = this.index;
+      for (r.isIdentifierStart(n) ? this.index++ : this.throwError("Unexpected " + this.char); this.index < this.expr.length && (n = this.code, r.isIdentifierPart(n)); )
+        this.index++;
+      return {
+        type: r.IDENTIFIER,
+        name: this.expr.slice(o, 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[]}
+     */
+  }, {
+    key: "gobbleArguments",
+    value: function(n) {
+      for (var o = [], h = !1, s = 0; this.index < this.expr.length; ) {
+        this.gobbleSpaces();
+        var c = this.code;
+        if (c === n) {
+          h = !0, this.index++, n === r.CPAREN_CODE && s && s >= o.length && this.throwError("Unexpected token " + String.fromCharCode(n));
+          break;
+        } else if (c === r.COMMA_CODE) {
+          if (this.index++, s++, s !== o.length) {
+            if (n === r.CPAREN_CODE)
+              this.throwError("Unexpected token ,");
+            else if (n === r.CBRACK_CODE)
+              for (var x = o.length; x < s; x++)
+                o.push(null);
+          }
+        } else if (o.length !== s && s !== 0)
+          this.throwError("Expected comma");
+        else {
+          var v = this.gobbleExpression();
+          (!v || v.type === r.COMPOUND) && this.throwError("Expected comma"), o.push(v);
+        }
+      }
+      return h || this.throwError("Expected " + String.fromCharCode(n)), o;
+    }
+    /**
+     * 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}
+     */
+  }, {
+    key: "gobbleGroup",
+    value: function() {
+      this.index++;
+      var n = this.gobbleExpressions(r.CPAREN_CODE);
+      if (this.code === r.CPAREN_CODE)
+        return this.index++, n.length === 1 ? n[0] : n.length ? {
+          type: r.SEQUENCE_EXP,
+          expressions: n
+        } : !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}
+     */
+  }, {
+    key: "gobbleArray",
+    value: function() {
+      return this.index++, {
+        type: r.ARRAY_EXP,
+        elements: this.gobbleArguments(r.CBRACK_CODE)
+      };
+    }
+  }], [{
+    key: "version",
+    get: (
+      /**
+       * @returns {string}
+       */
+      function() {
+        return "1.3.8";
+      }
+    )
+    /**
+     * @returns {string}
+     */
+  }, {
+    key: "toString",
+    value: function() {
+      return "JavaScript Expression Parser (JSEP) v" + r.version;
+    }
+  }, {
+    key: "addUnaryOp",
+    value: (
+      // ==================== CONFIG ================================
+      /**
+       * @method addUnaryOp
+       * @param {string} op_name The name of the unary op to add
+       * @returns {Jsep}
+       */
+      function(n) {
+        return r.max_unop_len = Math.max(n.length, r.max_unop_len), r.unary_ops[n] = 1, r;
+      }
+    )
+    /**
+     * @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}
+     */
+  }, {
+    key: "addBinaryOp",
+    value: function(n, o, h) {
+      return r.max_binop_len = Math.max(n.length, r.max_binop_len), r.binary_ops[n] = o, h ? r.right_associative.add(n) : r.right_associative.delete(n), r;
+    }
+    /**
+     * @method addIdentifierChar
+     * @param {string} char The additional character to treat as a valid part of an identifier
+     * @returns {Jsep}
+     */
+  }, {
+    key: "addIdentifierChar",
+    value: function(n) {
+      return r.additional_identifier_chars.add(n), r;
+    }
+    /**
+     * @method addLiteral
+     * @param {string} literal_name The name of the literal to add
+     * @param {*} literal_value The value of the literal
+     * @returns {Jsep}
+     */
+  }, {
+    key: "addLiteral",
+    value: function(n, o) {
+      return r.literals[n] = o, r;
+    }
+    /**
+     * @method removeUnaryOp
+     * @param {string} op_name The name of the unary op to remove
+     * @returns {Jsep}
+     */
+  }, {
+    key: "removeUnaryOp",
+    value: function(n) {
+      return delete r.unary_ops[n], n.length === r.max_unop_len && (r.max_unop_len = r.getMaxKeyLen(r.unary_ops)), r;
+    }
+    /**
+     * @method removeAllUnaryOps
+     * @returns {Jsep}
+     */
+  }, {
+    key: "removeAllUnaryOps",
+    value: function() {
+      return r.unary_ops = {}, r.max_unop_len = 0, r;
+    }
+    /**
+     * @method removeIdentifierChar
+     * @param {string} char The additional character to stop treating as a valid part of an identifier
+     * @returns {Jsep}
+     */
+  }, {
+    key: "removeIdentifierChar",
+    value: function(n) {
+      return r.additional_identifier_chars.delete(n), r;
+    }
+    /**
+     * @method removeBinaryOp
+     * @param {string} op_name The name of the binary op to remove
+     * @returns {Jsep}
+     */
+  }, {
+    key: "removeBinaryOp",
+    value: function(n) {
+      return delete r.binary_ops[n], n.length === r.max_binop_len && (r.max_binop_len = r.getMaxKeyLen(r.binary_ops)), r.right_associative.delete(n), r;
+    }
+    /**
+     * @method removeAllBinaryOps
+     * @returns {Jsep}
+     */
+  }, {
+    key: "removeAllBinaryOps",
+    value: function() {
+      return r.binary_ops = {}, r.max_binop_len = 0, r;
+    }
+    /**
+     * @method removeLiteral
+     * @param {string} literal_name The name of the literal to remove
+     * @returns {Jsep}
+     */
+  }, {
+    key: "removeLiteral",
+    value: function(n) {
+      return delete r.literals[n], r;
+    }
+    /**
+     * @method removeAllLiterals
+     * @returns {Jsep}
+     */
+  }, {
+    key: "removeAllLiterals",
+    value: function() {
+      return r.literals = {}, r;
+    }
+  }, {
+    key: "parse",
+    value: function(n) {
+      return new r(n).parse();
+    }
+    /**
+     * Get the longest key length of any object
+     * @param {object} obj
+     * @returns {number}
+     */
+  }, {
+    key: "getMaxKeyLen",
+    value: function(n) {
+      return Math.max.apply(Math, [0].concat(Ze(Object.keys(n).map(function(o) {
+        return o.length;
+      }))));
+    }
+    /**
+     * `ch` is a character code in the next three functions
+     * @param {number} ch
+     * @returns {boolean}
+     */
+  }, {
+    key: "isDecimalDigit",
+    value: function(n) {
+      return n >= 48 && n <= 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}
+     */
+  }, {
+    key: "binaryPrecedence",
+    value: function(n) {
+      return r.binary_ops[n] || 0;
+    }
+    /**
+     * Looks for start of identifier
+     * @param {number} ch
+     * @returns {boolean}
+     */
+  }, {
+    key: "isIdentifierStart",
+    value: function(n) {
+      return n >= 65 && n <= 90 || // A...Z
+      n >= 97 && n <= 122 || // a...z
+      n >= 128 && !r.binary_ops[String.fromCharCode(n)] || // any non-ASCII that is not an operator
+      r.additional_identifier_chars.has(String.fromCharCode(n));
+    }
+    /**
+     * @param {number} ch
+     * @returns {boolean}
+     */
+  }, {
+    key: "isIdentifierPart",
+    value: function(n) {
+      return r.isIdentifierStart(n) || r.isDecimalDigit(n);
+    }
+  }]);
+}(), Ar = new Er();
+Object.assign(de, {
+  hooks: Ar,
+  plugins: new gr(de),
+  // 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,
+    "&&": 2,
+    "|": 3,
+    "^": 4,
+    "&": 5,
+    "==": 6,
+    "!=": 6,
+    "===": 6,
+    "!==": 6,
+    "<": 7,
+    ">": 7,
+    "<=": 7,
+    ">=": 7,
+    "<<": 8,
+    ">>": 8,
+    ">>>": 8,
+    "+": 9,
+    "-": 9,
+    "*": 10,
+    "/": 10,
+    "%": 10
+  },
+  // 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"
+});
+de.max_unop_len = de.getMaxKeyLen(de.unary_ops);
+de.max_binop_len = de.getMaxKeyLen(de.binary_ops);
+var _e = function(i) {
+  return new de(i).parse();
+}, vr = Object.getOwnPropertyNames(de);
+vr.forEach(function(r) {
+  _e[r] === void 0 && r !== "prototype" && (_e[r] = de[r]);
+});
+_e.Jsep = de;
+var br = "ConditionalExpression", Fr = {
+  name: "ternary",
+  init: function(i) {
+    i.hooks.add("after-expression", function(o) {
+      if (o.node && this.code === i.QUMARK_CODE) {
+        this.index++;
+        var h = o.node, s = this.gobbleExpression();
+        if (s || this.throwError("Expected expression"), this.gobbleSpaces(), this.code === i.COLON_CODE) {
+          this.index++;
+          var c = this.gobbleExpression();
+          if (c || this.throwError("Expected expression"), o.node = {
+            type: br,
+            test: h,
+            consequent: s,
+            alternate: c
+          }, h.operator && i.binary_ops[h.operator] <= 0.9) {
+            for (var x = h; x.right.operator && i.binary_ops[x.right.operator] <= 0.9; )
+              x = x.right;
+            o.node.test = x.right, x.right = o.node, o.node = h;
+          }
+        } else
+          this.throwError("Expected :");
+      }
+    });
+  }
+};
+_e.plugins.register(Fr);
+var dt = 47, Cr = 92, Dr = {
+  name: "regex",
+  init: function(i) {
+    i.hooks.add("gobble-token", function(o) {
+      if (this.code === dt) {
+        for (var h = ++this.index, s = !1; this.index < this.expr.length; ) {
+          if (this.code === dt && !s) {
+            for (var c = this.expr.slice(h, this.index), x = ""; ++this.index < this.expr.length; ) {
+              var v = this.code;
+              if (v >= 97 && v <= 122 || v >= 65 && v <= 90 || v >= 48 && v <= 57)
+                x += this.char;
+              else
+                break;
+            }
+            var C = void 0;
+            try {
+              C = new RegExp(c, x);
+            } catch (m) {
+              this.throwError(m.message);
+            }
+            return o.node = {
+              type: i.LITERAL,
+              value: C,
+              raw: this.expr.slice(h - 1, this.index)
+            }, o.node = this.gobbleTokenProperty(o.node), o.node;
+          }
+          this.code === i.OBRACK_CODE ? s = !0 : s && this.code === i.CBRACK_CODE && (s = !1), this.index += this.code === Cr ? 2 : 1;
+        }
+        this.throwError("Unclosed Regex");
+      }
+    });
+  }
+}, Ke = 43, xr = 45, Se = {
+  name: "assignment",
+  assignmentOperators: /* @__PURE__ */ new Set(["=", "*=", "**=", "/=", "%=", "+=", "-=", "<<=", ">>=", ">>>=", "&=", "^=", "|="]),
+  updateOperators: [Ke, xr],
+  assignmentPrecedence: 0.9,
+  init: function(i) {
+    var n = [i.IDENTIFIER, i.MEMBER_EXP];
+    Se.assignmentOperators.forEach(function(h) {
+      return i.addBinaryOp(h, Se.assignmentPrecedence, !0);
+    }), i.hooks.add("gobble-token", function(s) {
+      var c = this, x = this.code;
+      Se.updateOperators.some(function(v) {
+        return v === x && v === c.expr.charCodeAt(c.index + 1);
+      }) && (this.index += 2, s.node = {
+        type: "UpdateExpression",
+        operator: x === Ke ? "++" : "--",
+        argument: this.gobbleTokenProperty(this.gobbleIdentifier()),
+        prefix: !0
+      }, (!s.node.argument || !n.includes(s.node.argument.type)) && this.throwError("Unexpected ".concat(s.node.operator)));
+    }), i.hooks.add("after-token", function(s) {
+      var c = this;
+      if (s.node) {
+        var x = this.code;
+        Se.updateOperators.some(function(v) {
+          return v === x && v === c.expr.charCodeAt(c.index + 1);
+        }) && (n.includes(s.node.type) || this.throwError("Unexpected ".concat(s.node.operator)), this.index += 2, s.node = {
+          type: "UpdateExpression",
+          operator: x === Ke ? "++" : "--",
+          argument: s.node,
+          prefix: !1
+        });
+      }
+    }), i.hooks.add("after-expression", function(s) {
+      s.node && o(s.node);
+    });
+    function o(h) {
+      Se.assignmentOperators.has(h.operator) ? (h.type = "AssignmentExpression", o(h.left), o(h.right)) : h.operator || Object.values(h).forEach(function(s) {
+        s && ye(s) === "object" && o(s);
+      });
+    }
+  }
+}, le = Object.prototype.hasOwnProperty;
+function Fe(r, i) {
+  return r = r.slice(), r.push(i), r;
+}
+function Qe(r, i) {
+  return i = i.slice(), i.unshift(r), i;
+}
+var Sr = /* @__PURE__ */ function(r) {
+  function i(n) {
+    var o;
+    return ke(this, i), o = ur(this, i, ['JSONPath should not be called with "new" (it prevents return of (unwrapped) scalar values)']), o.avoidNew = !0, o.value = n, o.name = "NewError", o;
+  }
+  return lr(i, r), Be(i);
+}(/* @__PURE__ */ Ve(Error));
+function X(r, i, n, o, h) {
+  if (!(this instanceof X))
+    try {
+      return new X(r, i, n, o, h);
+    } catch (v) {
+      if (!v.avoidNew)
+        throw v;
+      return v.value;
+    }
+  typeof r == "string" && (h = o, o = n, n = i, i = r, r = null);
+  var s = r && ye(r) === "object";
+  if (r = r || {}, this.json = r.json || n, this.path = r.path || i, this.resultType = r.resultType || "value", this.flatten = r.flatten || !1, this.wrap = le.call(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 || o || null, this.otherTypeCallback = r.otherTypeCallback || h || function() {
+    throw new TypeError("You must supply an otherTypeCallback callback option with the @other() operator.");
+  }, r.autostart !== !1) {
+    var c = {
+      path: s ? r.path : i
+    };
+    s ? "json" in r && (c.json = r.json) : c.json = n;
+    var x = this.evaluate(c);
+    if (!x || ye(x) !== "object")
+      throw new Sr(x);
+    return x;
+  }
+}
+X.prototype.evaluate = function(r, i, n, o) {
+  var h = this, s = this.parent, c = this.parentProperty, x = this.flatten, v = this.wrap;
+  if (this.currResultType = this.resultType, this.currEval = this.eval, this.currSandbox = this.sandbox, n = n || this.callback, this.currOtherTypeCallback = o || this.otherTypeCallback, i = i || this.json, r = r || this.path, r && ye(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 (!le.call(r, "json"))
+      throw new TypeError('You must supply a "json" property when providing an object argument to JSONPath.evaluate().');
+    var C = r;
+    i = C.json, x = le.call(r, "flatten") ? r.flatten : x, this.currResultType = le.call(r, "resultType") ? r.resultType : this.currResultType, this.currSandbox = le.call(r, "sandbox") ? r.sandbox : this.currSandbox, v = le.call(r, "wrap") ? r.wrap : v, this.currEval = le.call(r, "eval") ? r.eval : this.currEval, n = le.call(r, "callback") ? r.callback : n, this.currOtherTypeCallback = le.call(r, "otherTypeCallback") ? r.otherTypeCallback : this.currOtherTypeCallback, s = le.call(r, "parent") ? r.parent : s, c = le.call(r, "parentProperty") ? r.parentProperty : c, r = r.path;
+  }
+  if (s = s || null, c = c || null, Array.isArray(r) && (r = X.toPathString(r)), !(!r && r !== "" || !i)) {
+    var m = X.toPathArray(r);
+    m[0] === "$" && m.length > 1 && m.shift(), this._hasParentSelector = null;
+    var p = this._trace(m, i, ["$"], s, c, n).filter(function(y) {
+      return y && !y.isParentSelector;
+    });
+    return p.length ? !v && p.length === 1 && !p[0].hasArrExpr ? this._getPreferredOutput(p[0]) : p.reduce(function(y, F) {
+      var d = h._getPreferredOutput(F);
+      return x && Array.isArray(d) ? y = y.concat(d) : y.push(d), y;
+    }, []) : v ? [] : void 0;
+  }
+};
+X.prototype._getPreferredOutput = function(r) {
+  var i = this.currResultType;
+  switch (i) {
+    case "all": {
+      var n = Array.isArray(r.path) ? r.path : X.toPathArray(r.path);
+      return r.pointer = X.toPointer(n), r.path = typeof r.path == "string" ? r.path : X.toPathString(r.path), r;
+    }
+    case "value":
+    case "parent":
+    case "parentProperty":
+      return r[i];
+    case "path":
+      return X.toPathString(r[i]);
+    case "pointer":
+      return X.toPointer(r.path);
+    default:
+      throw new TypeError("Unknown result type");
+  }
+};
+X.prototype._handleCallback = function(r, i, n) {
+  if (i) {
+    var o = this._getPreferredOutput(r);
+    r.path = typeof r.path == "string" ? r.path : X.toPathString(r.path), i(o, n, r);
+  }
+};
+X.prototype._trace = function(r, i, n, o, h, s, c, x) {
+  var v = this, C;
+  if (!r.length)
+    return C = {
+      path: n,
+      value: i,
+      parent: o,
+      parentProperty: h,
+      hasArrExpr: c
+    }, this._handleCallback(C, s, "value"), C;
+  var m = r[0], p = r.slice(1), y = [];
+  function F(N) {
+    Array.isArray(N) ? N.forEach(function(U) {
+      y.push(U);
+    }) : y.push(N);
+  }
+  if ((typeof m != "string" || x) && i && le.call(i, m))
+    F(this._trace(p, i[m], Fe(n, m), i, m, s, c));
+  else if (m === "*")
+    this._walk(i, function(N) {
+      F(v._trace(p, i[N], Fe(n, N), i, N, s, !0, !0));
+    });
+  else if (m === "..")
+    F(this._trace(p, i, n, o, h, s, c)), this._walk(i, function(N) {
+      ye(i[N]) === "object" && F(v._trace(r.slice(), i[N], Fe(n, N), i, N, s, !0));
+    });
+  else {
+    if (m === "^")
+      return this._hasParentSelector = !0, {
+        path: n.slice(0, -1),
+        expr: p,
+        isParentSelector: !0
+      };
+    if (m === "~")
+      return C = {
+        path: Fe(n, m),
+        value: h,
+        parent: o,
+        parentProperty: null
+      }, this._handleCallback(C, s, "property"), C;
+    if (m === "$")
+      F(this._trace(p, i, n, null, null, s, c));
+    else if (/^(\x2D?[0-9]*):(\x2D?[0-9]*):?([0-9]*)$/.test(m))
+      F(this._slice(m, p, i, n, o, h, s));
+    else if (m.indexOf("?(") === 0) {
+      if (this.currEval === !1)
+        throw new Error("Eval [?(expr)] prevented in JSONPath expression.");
+      var d = m.replace(/^\?\(((?:[\0-\t\x0B\f\x0E-\u2027\u202A-\uD7FF\uE000-\uFFFF]|[\uD800-\uDBFF][\uDC00-\uDFFF]|[\uD800-\uDBFF](?![\uDC00-\uDFFF])|(?:[^\uD800-\uDBFF]|^)[\uDC00-\uDFFF])*?)\)$/, "$1"), E = /@(?:[\0-\t\x0B\f\x0E-\u2027\u202A-\uD7FF\uE000-\uFFFF]|[\uD800-\uDBFF][\uDC00-\uDFFF]|[\uD800-\uDBFF](?![\uDC00-\uDFFF])|(?:[^\uD800-\uDBFF]|^)[\uDC00-\uDFFF])?((?:[\0->@-\uD7FF\uE000-\uFFFF]|[\uD800-\uDBFF][\uDC00-\uDFFF]|[\uD800-\uDBFF](?![\uDC00-\uDFFF])|(?:[^\uD800-\uDBFF]|^)[\uDC00-\uDFFF])*)['\[](\??\((?:[\0-\t\x0B\f\x0E-\u2027\u202A-\uD7FF\uE000-\uFFFF]|[\uD800-\uDBFF][\uDC00-\uDFFF]|[\uD800-\uDBFF](?![\uDC00-\uDFFF])|(?:[^\uD800-\uDBFF]|^)[\uDC00-\uDFFF])*?\))(?!(?:[\0-\t\x0B\f\x0E-\u2027\u202A-\uD7FF\uE000-\uFFFF]|[\uD800-\uDBFF][\uDC00-\uDFFF]|[\uD800-\uDBFF](?![\uDC00-\uDFFF])|(?:[^\uD800-\uDBFF]|^)[\uDC00-\uDFFF])\)\])['\]]/g.exec(d);
+      E ? this._walk(i, function(N) {
+        var U = [E[2]], q = E[1] ? i[N][E[1]] : i[N], V = v._trace(U, q, n, o, h, s, !0);
+        V.length > 0 && F(v._trace(p, i[N], Fe(n, N), i, N, s, !0));
+      }) : this._walk(i, function(N) {
+        v._eval(d, i[N], N, n, o, h) && F(v._trace(p, i[N], Fe(n, N), i, N, s, !0));
+      });
+    } else if (m[0] === "(") {
+      if (this.currEval === !1)
+        throw new Error("Eval [(expr)] prevented in JSONPath expression.");
+      F(this._trace(Qe(this._eval(m, i, n[n.length - 1], n.slice(0, -1), o, h), p), i, n, o, h, s, c));
+    } else if (m[0] === "@") {
+      var u = !1, S = m.slice(1, -2);
+      switch (S) {
+        case "scalar":
+          (!i || !["object", "function"].includes(ye(i))) && (u = !0);
+          break;
+        case "boolean":
+        case "string":
+        case "undefined":
+        case "function":
+          ye(i) === S && (u = !0);
+          break;
+        case "integer":
+          Number.isFinite(i) && !(i % 1) && (u = !0);
+          break;
+        case "number":
+          Number.isFinite(i) && (u = !0);
+          break;
+        case "nonFinite":
+          typeof i == "number" && !Number.isFinite(i) && (u = !0);
+          break;
+        case "object":
+          i && ye(i) === S && (u = !0);
+          break;
+        case "array":
+          Array.isArray(i) && (u = !0);
+          break;
+        case "other":
+          u = this.currOtherTypeCallback(i, n, o, h);
+          break;
+        case "null":
+          i === null && (u = !0);
+          break;
+        default:
+          throw new TypeError("Unknown value type " + S);
+      }
+      if (u)
+        return C = {
+          path: n,
+          value: i,
+          parent: o,
+          parentProperty: h
+        }, this._handleCallback(C, s, "value"), C;
+    } else if (m[0] === "`" && i && le.call(i, m.slice(1))) {
+      var B = m.slice(1);
+      F(this._trace(p, i[B], Fe(n, B), i, B, s, c, !0));
+    } else if (m.includes(",")) {
+      var D = m.split(","), a = mr(D), f;
+      try {
+        for (a.s(); !(f = a.n()).done; ) {
+          var b = f.value;
+          F(this._trace(Qe(b, p), i, n, o, h, s, !0));
+        }
+      } catch (N) {
+        a.e(N);
+      } finally {
+        a.f();
+      }
+    } else
+      !x && i && le.call(i, m) && F(this._trace(p, i[m], Fe(n, m), i, m, s, c, !0));
+  }
+  if (this._hasParentSelector)
+    for (var g = 0; g < y.length; g++) {
+      var I = y[g];
+      if (I && I.isParentSelector) {
+        var M = this._trace(I.expr, i, I.path, o, h, s, c);
+        if (Array.isArray(M)) {
+          y[g] = M[0];
+          for (var z = M.length, T = 1; T < z; T++)
+            g++, y.splice(g, 0, M[T]);
+        } else
+          y[g] = M;
+      }
+    }
+  return y;
+};
+X.prototype._walk = function(r, i) {
+  if (Array.isArray(r))
+    for (var n = r.length, o = 0; o < n; o++)
+      i(o);
+  else
+    r && ye(r) === "object" && Object.keys(r).forEach(function(h) {
+      i(h);
+    });
+};
+X.prototype._slice = function(r, i, n, o, h, s, c) {
+  if (Array.isArray(n)) {
+    var x = n.length, v = r.split(":"), C = v[2] && Number.parseInt(v[2]) || 1, m = v[0] && Number.parseInt(v[0]) || 0, p = v[1] && Number.parseInt(v[1]) || x;
+    m = m < 0 ? Math.max(0, m + x) : Math.min(x, m), p = p < 0 ? Math.max(0, p + x) : Math.min(x, p);
+    for (var y = [], F = m; F < p; F += C) {
+      var d = this._trace(Qe(F, i), n, o, h, s, c, !0);
+      d.forEach(function(E) {
+        y.push(E);
+      });
+    }
+    return y;
+  }
+};
+X.prototype._eval = function(r, i, n, o, h, s) {
+  var c = this;
+  this.currSandbox._$_parentProperty = s, this.currSandbox._$_parent = h, this.currSandbox._$_property = n, this.currSandbox._$_root = this.json, this.currSandbox._$_v = i;
+  var x = r.includes("@path");
+  x && (this.currSandbox._$_path = X.toPathString(o.concat([n])));
+  var v = this.currEval + "Script:" + r;
+  if (!X.cache[v]) {
+    var C = r.replace(/@parentProperty/g, "_$_parentProperty").replace(/@parent/g, "_$_parent").replace(/@property/g, "_$_property").replace(/@root/g, "_$_root").replace(/@([\t-\r \)\.\[\xA0\u1680\u2000-\u200A\u2028\u2029\u202F\u205F\u3000\uFEFF])/g, "_$_v$1");
+    if (x && (C = C.replace(/@path/g, "_$_path")), this.currEval === "safe" || this.currEval === !0 || this.currEval === void 0)
+      X.cache[v] = new this.safeVm.Script(C);
+    else if (this.currEval === "native")
+      X.cache[v] = new this.vm.Script(C);
+    else if (typeof this.currEval == "function" && this.currEval.prototype && le.call(this.currEval.prototype, "runInNewContext")) {
+      var m = this.currEval;
+      X.cache[v] = new m(C);
+    } else if (typeof this.currEval == "function")
+      X.cache[v] = {
+        runInNewContext: function(y) {
+          return c.currEval(C, y);
+        }
+      };
+    else
+      throw new TypeError('Unknown "eval" property "'.concat(this.currEval, '"'));
+  }
+  try {
+    return X.cache[v].runInNewContext(this.currSandbox);
+  } catch (p) {
+    if (this.ignoreEvalErrors)
+      return !1;
+    throw new Error("jsonPath: " + p.message + ": " + r);
+  }
+};
+X.cache = {};
+X.toPathString = function(r) {
+  for (var i = r, n = i.length, o = "$", h = 1; h < n; h++)
+    /^(~|\^|@(?:[\0-\t\x0B\f\x0E-\u2027\u202A-\uD7FF\uE000-\uFFFF]|[\uD800-\uDBFF][\uDC00-\uDFFF]|[\uD800-\uDBFF](?![\uDC00-\uDFFF])|(?:[^\uD800-\uDBFF]|^)[\uDC00-\uDFFF])*?\(\))$/.test(i[h]) || (o += /^[\*0-9]+$/.test(i[h]) ? "[" + i[h] + "]" : "['" + i[h] + "']");
+  return o;
+};
+X.toPointer = function(r) {
+  for (var i = r, n = i.length, o = "", h = 1; h < n; h++)
+    /^(~|\^|@(?:[\0-\t\x0B\f\x0E-\u2027\u202A-\uD7FF\uE000-\uFFFF]|[\uD800-\uDBFF][\uDC00-\uDFFF]|[\uD800-\uDBFF](?![\uDC00-\uDFFF])|(?:[^\uD800-\uDBFF]|^)[\uDC00-\uDFFF])*?\(\))$/.test(i[h]) || (o += "/" + i[h].toString().replace(/~/g, "~0").replace(/\//g, "~1"));
+  return o;
+};
+X.toPathArray = function(r) {
+  var i = X.cache;
+  if (i[r])
+    return i[r].concat();
+  var n = [], o = r.replace(/@(?:null|boolean|number|string|integer|undefined|nonFinite|scalar|array|object|function|other)\(\)/g, ";$&;").replace(/['\[](\??\((?:[\0-\t\x0B\f\x0E-\u2027\u202A-\uD7FF\uE000-\uFFFF]|[\uD800-\uDBFF][\uDC00-\uDFFF]|[\uD800-\uDBFF](?![\uDC00-\uDFFF])|(?:[^\uD800-\uDBFF]|^)[\uDC00-\uDFFF])*?\))['\]](?!(?:[\0-\t\x0B\f\x0E-\u2027\u202A-\uD7FF\uE000-\uFFFF]|[\uD800-\uDBFF][\uDC00-\uDFFF]|[\uD800-\uDBFF](?![\uDC00-\uDFFF])|(?:[^\uD800-\uDBFF]|^)[\uDC00-\uDFFF])\])/g, function(s, c) {
+    return "[#" + (n.push(c) - 1) + "]";
+  }).replace(/\[["']((?:[\0-&\(-\\\^-\uD7FF\uE000-\uFFFF]|[\uD800-\uDBFF][\uDC00-\uDFFF]|[\uD800-\uDBFF](?![\uDC00-\uDFFF])|(?:[^\uD800-\uDBFF]|^)[\uDC00-\uDFFF])*)["']\]/g, function(s, c) {
+    return "['" + c.replace(/\./g, "%@%").replace(/~/g, "%%@@%%") + "']";
+  }).replace(/~/g, ";~;").replace(/["']?\.["']?(?!(?:[\0-Z\\-\uD7FF\uE000-\uFFFF]|[\uD800-\uDBFF][\uDC00-\uDFFF]|[\uD800-\uDBFF](?![\uDC00-\uDFFF])|(?:[^\uD800-\uDBFF]|^)[\uDC00-\uDFFF])*\])|\[["']?/g, ";").replace(/%@%/g, ".").replace(/%%@@%%/g, "~").replace(/(?:;)?(\^+)(?:;)?/g, function(s, c) {
+    return ";" + c.split("").join(";") + ";";
+  }).replace(/;;;|;;/g, ";..;").replace(/;$|'?\]|'$/g, ""), h = o.split(";").map(function(s) {
+    var c = s.match(/#([0-9]+)/);
+    return !c || !c[1] ? s : n[c[1]];
+  });
+  return i[r] = h, i[r].concat();
+};
+var _r = function(i, n, o) {
+  for (var h = i.length, s = 0; s < h; s++) {
+    var c = i[s];
+    o(c) && n.push(i.splice(s--, 1)[0]);
+  }
+};
+_e.plugins.register(Dr, Se);
+var Y = {
+  /**
+   * @param {jsep.Expression} ast
+   * @param {Record<string, any>} subs
+   */
+  evalAst: function(i, n) {
+    switch (i.type) {
+      case "BinaryExpression":
+      case "LogicalExpression":
+        return Y.evalBinaryExpression(i, n);
+      case "Compound":
+        return Y.evalCompound(i, n);
+      case "ConditionalExpression":
+        return Y.evalConditionalExpression(i, n);
+      case "Identifier":
+        return Y.evalIdentifier(i, n);
+      case "Literal":
+        return Y.evalLiteral(i, n);
+      case "MemberExpression":
+        return Y.evalMemberExpression(i, n);
+      case "UnaryExpression":
+        return Y.evalUnaryExpression(i, n);
+      case "ArrayExpression":
+        return Y.evalArrayExpression(i, n);
+      case "CallExpression":
+        return Y.evalCallExpression(i, n);
+      case "AssignmentExpression":
+        return Y.evalAssignmentExpression(i, n);
+      default:
+        throw SyntaxError("Unexpected expression", i);
+    }
+  },
+  evalBinaryExpression: function(i, n) {
+    var o = {
+      "||": function(s, c) {
+        return s || c();
+      },
+      "&&": function(s, c) {
+        return s && c();
+      },
+      "|": function(s, c) {
+        return s | c();
+      },
+      "^": function(s, c) {
+        return s ^ c();
+      },
+      "&": function(s, c) {
+        return s & c();
+      },
+      // eslint-disable-next-line eqeqeq
+      "==": function(s, c) {
+        return s == c();
+      },
+      // eslint-disable-next-line eqeqeq
+      "!=": function(s, c) {
+        return s != c();
+      },
+      "===": function(s, c) {
+        return s === c();
+      },
+      "!==": function(s, c) {
+        return s !== c();
+      },
+      "<": function(s, c) {
+        return s < c();
+      },
+      ">": function(s, c) {
+        return s > c();
+      },
+      "<=": function(s, c) {
+        return s <= c();
+      },
+      ">=": function(s, c) {
+        return s >= c();
+      },
+      "<<": function(s, c) {
+        return s << c();
+      },
+      ">>": function(s, c) {
+        return s >> c();
+      },
+      ">>>": function(s, c) {
+        return s >>> c();
+      },
+      "+": function(s, c) {
+        return s + c();
+      },
+      "-": function(s, c) {
+        return s - c();
+      },
+      "*": function(s, c) {
+        return s * c();
+      },
+      "/": function(s, c) {
+        return s / c();
+      },
+      "%": function(s, c) {
+        return s % c();
+      }
+    }[i.operator](Y.evalAst(i.left, n), function() {
+      return Y.evalAst(i.right, n);
+    });
+    return o;
+  },
+  evalCompound: function(i, n) {
+    for (var o, h = 0; h < i.body.length; h++) {
+      i.body[h].type === "Identifier" && ["var", "let", "const"].includes(i.body[h].name) && i.body[h + 1] && i.body[h + 1].type === "AssignmentExpression" && (h += 1);
+      var s = i.body[h];
+      o = Y.evalAst(s, n);
+    }
+    return o;
+  },
+  evalConditionalExpression: function(i, n) {
+    return Y.evalAst(i.test, n) ? Y.evalAst(i.consequent, n) : Y.evalAst(i.alternate, n);
+  },
+  evalIdentifier: function(i, n) {
+    if (i.name in n)
+      return n[i.name];
+    throw ReferenceError("".concat(i.name, " is not defined"));
+  },
+  evalLiteral: function(i) {
+    return i.value;
+  },
+  evalMemberExpression: function(i, n) {
+    var o = i.computed ? Y.evalAst(i.property) : i.property.name, h = Y.evalAst(i.object, n), s = h[o];
+    return typeof s == "function" ? s.bind(h) : s;
+  },
+  evalUnaryExpression: function(i, n) {
+    var o = {
+      "-": function(s) {
+        return -Y.evalAst(s, n);
+      },
+      "!": function(s) {
+        return !Y.evalAst(s, n);
+      },
+      "~": function(s) {
+        return ~Y.evalAst(s, n);
+      },
+      // eslint-disable-next-line no-implicit-coercion
+      "+": function(s) {
+        return +Y.evalAst(s, n);
+      }
+    }[i.operator](i.argument);
+    return o;
+  },
+  evalArrayExpression: function(i, n) {
+    return i.elements.map(function(o) {
+      return Y.evalAst(o, n);
+    });
+  },
+  evalCallExpression: function(i, n) {
+    var o = i.arguments.map(function(s) {
+      return Y.evalAst(s, n);
+    }), h = Y.evalAst(i.callee, n);
+    return h.apply(void 0, Ze(o));
+  },
+  evalAssignmentExpression: function(i, n) {
+    if (i.left.type !== "Identifier")
+      throw SyntaxError("Invalid left-hand side in assignment");
+    var o = i.left.name, h = Y.evalAst(i.right, n);
+    return n[o] = h, n[o];
+  }
+}, kr = /* @__PURE__ */ function() {
+  function r(i) {
+    ke(this, r), this.code = i, this.ast = _e(this.code);
+  }
+  return Be(r, [{
+    key: "runInNewContext",
+    value: function(n) {
+      var o = ar({}, n);
+      return Y.evalAst(this.ast, o);
+    }
+  }]);
+}(), Br = /* @__PURE__ */ function() {
+  function r(i) {
+    ke(this, r), this.code = i;
+  }
+  return Be(r, [{
+    key: "runInNewContext",
+    value: function(n) {
+      var o = this.code, h = Object.keys(n), s = [];
+      _r(h, s, function(m) {
+        return typeof n[m] == "function";
+      });
+      var c = h.map(function(m) {
+        return n[m];
+      }), x = s.reduce(function(m, p) {
+        var y = n[p].toString();
+        return /function/.test(y) || (y = "function " + y), "var " + p + "=" + y + ";" + m;
+      }, "");
+      o = x + o, !/(["'])use strict\1/.test(o) && !h.includes("arguments") && (o = "var arguments = undefined;" + o), o = o.replace(/;[\t-\r \xA0\u1680\u2000-\u200A\u2028\u2029\u202F\u205F\u3000\uFEFF]*$/, "");
+      var v = o.lastIndexOf(";"), C = v > -1 ? o.slice(0, v + 1) + " return " + o.slice(v + 1) : " return " + o;
+      return mt(Function, h.concat([C])).apply(void 0, Ze(c));
+    }
+  }]);
+}();
+X.prototype.vm = {
+  Script: Br
+};
+X.prototype.safeVm = {
+  Script: kr
+};
+const Ir = (r, i) => {
+  if (!i || !r)
+    return null;
+  if (r.indexOf("$") == -1 && r.indexOf(".") == -1)
+    return i == null ? void 0 : i[r];
+  var n = We.query(i, r);
+  return r.endsWith("]") ? n : n[0];
+}, Pr = (r, i) => {
+  if (!i || !r)
+    return null;
+  var n = X({ json: i, path: r });
+  return n;
+};
+export {
+  Ir as a,
+  Pr as q
+};