@ea-lab/reactive-json 0.7.0 → 1.0.0-alpha.0

package/dist/TemplateSystem-kQJEKjik.js

@@ -0,0 +1,3568 @@
+import { useContext as Ee, useRef as Zt } from "react";
+import { GlobalDataContext as we } from "./engine/GlobalDataContext.js";
+import { TemplateContext as be } from "./engine/TemplateContext.js";
+import { jsx as le, jsxs as ut, Fragment as it } from "react/jsx-runtime";
+import { c as at, g as er } from "./_commonjsHelpers-DaMA6jEr.js";
+import { l as st } from "./lodash-CYNxjS-I.js";
+function ve({ props: E, currentData: P, datafield: x, path: k }) {
+  const D = Ee(we), C = Ee(be), l = D.plugins ?? {}, S = (l == null ? void 0 : l.element) ?? {};
+  if (!S)
+    return null;
+  const { element: d } = D;
+  if (P === void 0 && (P = ""), E != null && E.type) {
+    let f = S[E.type] ?? void 0;
+    return f === void 0 && (f = S.Html ?? ct), (S.Html ?? ct) === f && (E.tag = E.tag ?? E.type), /* @__PURE__ */ le(f, { path: k, props: E, currentData: P, datafield: x });
+  }
+  if (E != null && E.load) {
+    let f;
+    const h = (E == null ? void 0 : E.customDataLocation) ?? void 0, a = h ? (
+      // The data is located somewhere in the current data.
+      ke({
+        globalDataContext: D,
+        templateContext: C,
+        valueToEvaluate: h
+      })
+    ) : (
+      // The data is the current data.
+      P
+    ), o = h ? ft({
+      dataLocation: h,
+      currentPath: k,
+      globalDataContext: D,
+      templateContext: C
+    }) : k;
+    typeof E.load == "function" ? f = E.load(a) : f = d[E.load];
+    const { load: A, customDataLocation: s, ...p } = E;
+    return f = { ...f, ...p }, E.keepTemplateContext ? /* @__PURE__ */ le(
+      ve,
+      {
+        currentData: a,
+        datafield: x,
+        path: o,
+        props: f
+      }
+    ) : /* @__PURE__ */ le(be.Provider, { value: { templateData: a, templatePath: o }, children: /* @__PURE__ */ le(
+      ve,
+      {
+        currentData: a,
+        datafield: x,
+        path: o,
+        props: f
+      }
+    ) });
+  }
+  return Array.isArray(E) ? E.map((f, h) => /* @__PURE__ */ le(
+    ve,
+    {
+      currentData: P[h] ?? void 0,
+      datafield: h,
+      path: k + "." + h,
+      props: f ?? void 0
+    },
+    k + "." + h
+  )) : typeof E == "object" ? Object.entries(E).map(([f, h]) => /* @__PURE__ */ le(
+    ve,
+    {
+      currentData: P[f] ?? void 0,
+      datafield: f ?? void 0,
+      path: k + "." + f,
+      props: h
+    },
+    k + "." + f
+  )) : /* @__PURE__ */ le(ar, { valueToEvaluate: P || (E ?? null) });
+}
+function Ne(E) {
+  throw new Error('Could not dynamically require "' + E + '". Please configure the dynamicRequireTargets or/and ignoreDynamicRequires option of @rollup/plugin-commonjs appropriately for this require call to work.');
+}
+var He = { exports: {} };
+/*! jsonpath 1.1.1 */
+var ot;
+function tr() {
+  return ot || (ot = 1, function(E, P) {
+    (function(x) {
+      E.exports = x();
+    })(function() {
+      return function x(k, D, C) {
+        function l(f, h) {
+          if (!D[f]) {
+            if (!k[f]) {
+              var a = typeof Ne == "function" && Ne;
+              if (!h && a) return a(f, !0);
+              if (S) return S(f, !0);
+              var o = new Error("Cannot find module '" + f + "'");
+              throw o.code = "MODULE_NOT_FOUND", o;
+            }
+            var A = D[f] = { exports: {} };
+            k[f][0].call(A.exports, function(s) {
+              var p = k[f][1][s];
+              return l(p || s);
+            }, A, A.exports, x, k, D, C);
+          }
+          return D[f].exports;
+        }
+        for (var S = typeof Ne == "function" && Ne, d = 0; d < C.length; d++) l(C[d]);
+        return l;
+      }({ "./aesprim": [function(x, k, D) {
+        (function(C, l) {
+          l(typeof D < "u" ? D : C.esprima = {});
+        })(this, function(C) {
+          var l, S, d, f, h, a, o, A, s, p, r, F, w, g, n, i, y, m;
+          l = {
+            BooleanLiteral: 1,
+            EOF: 2,
+            Identifier: 3,
+            Keyword: 4,
+            NullLiteral: 5,
+            NumericLiteral: 6,
+            Punctuator: 7,
+            StringLiteral: 8,
+            RegularExpression: 9
+          }, S = {}, S[l.BooleanLiteral] = "Boolean", S[l.EOF] = "<end>", S[l.Identifier] = "Identifier", S[l.Keyword] = "Keyword", S[l.NullLiteral] = "Null", S[l.NumericLiteral] = "Numeric", S[l.Punctuator] = "Punctuator", S[l.StringLiteral] = "String", S[l.RegularExpression] = "RegularExpression", d = [
+            "(",
+            "{",
+            "[",
+            "in",
+            "typeof",
+            "instanceof",
+            "new",
+            "return",
+            "case",
+            "delete",
+            "throw",
+            "void",
+            // assignment operators
+            "=",
+            "+=",
+            "-=",
+            "*=",
+            "/=",
+            "%=",
+            "<<=",
+            ">>=",
+            ">>>=",
+            "&=",
+            "|=",
+            "^=",
+            ",",
+            // binary/unary operators
+            "+",
+            "-",
+            "*",
+            "/",
+            "%",
+            "++",
+            "--",
+            "<<",
+            ">>",
+            ">>>",
+            "&",
+            "|",
+            "^",
+            "!",
+            "~",
+            "&&",
+            "||",
+            "?",
+            ":",
+            "===",
+            "==",
+            ">=",
+            "<=",
+            "<",
+            ">",
+            "!=",
+            "!=="
+          ], f = {
+            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"
+          }, h = {
+            Data: 1,
+            Get: 2,
+            Set: 4
+          }, a = {
+            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"
+          }, o = {
+            NonAsciiIdentifierStart: new RegExp("[ªµºÀ-ÖØ-öø-ˁˆ-ˑˠ-ˤˬˮͰ-ʹͶͷͺ-ͽΆΈ-ΊΌΎ-ΡΣ-ϵϷ-ҁҊ-ԧԱ-Ֆՙա-ևא-תװ-ײؠ-يٮٯٱ-ۓەۥۦۮۯۺ-ۼۿܐܒ-ܯݍ-ޥޱߊ-ߪߴߵߺࠀ-ࠕࠚࠤࠨࡀ-ࡘࢠࢢ-ࢬऄ-हऽॐक़-ॡॱ-ॷॹ-ॿঅ-ঌএঐও-নপ-রলশ-হঽৎড়ঢ়য়-ৡৰৱਅ-ਊਏਐਓ-ਨਪ-ਰਲਲ਼ਵਸ਼ਸਹਖ਼-ੜਫ਼ੲ-ੴઅ-ઍએ-ઑઓ-નપ-રલળવ-હઽૐૠૡଅ-ଌଏଐଓ-ନପ-ରଲଳଵ-ହଽଡ଼ଢ଼ୟ-ୡୱஃஅ-ஊஎ-ஐஒ-கஙசஜஞடணதந-பம-ஹௐఅ-ఌఎ-ఐఒ-నప-ళవ-హఽౘౙౠౡಅ-ಌಎ-ಐಒ-ನಪ-ಳವ-ಹಽೞೠೡೱೲഅ-ഌഎ-ഐഒ-ഺഽൎൠൡൺ-ൿඅ-ඖක-නඳ-රලව-ෆก-ะาำเ-ๆກຂຄງຈຊຍດ-ທນ-ຟມ-ຣລວສຫອ-ະາຳຽເ-ໄໆໜ-ໟༀཀ-ཇཉ-ཬྈ-ྌက-ဪဿၐ-ၕၚ-ၝၡၥၦၮ-ၰၵ-ႁႎႠ-ჅჇჍა-ჺჼ-ቈቊ-ቍቐ-ቖቘቚ-ቝበ-ኈኊ-ኍነ-ኰኲ-ኵኸ-ኾዀዂ-ዅወ-ዖዘ-ጐጒ-ጕጘ-ፚᎀ-ᎏᎠ-Ᏼᐁ-ᙬᙯ-ᙿᚁ-ᚚᚠ-ᛪᛮ-ᛰᜀ-ᜌᜎ-ᜑᜠ-ᜱᝀ-ᝑᝠ-ᝬᝮ-ᝰក-ឳៗៜᠠ-ᡷᢀ-ᢨᢪᢰ-ᣵᤀ-ᤜᥐ-ᥭᥰ-ᥴᦀ-ᦫᧁ-ᧇᨀ-ᨖᨠ-ᩔᪧᬅ-ᬳᭅ-ᭋᮃ-ᮠᮮᮯᮺ-ᯥᰀ-ᰣᱍ-ᱏᱚ-ᱽᳩ-ᳬᳮ-ᳱᳵᳶᴀ-ᶿḀ-ἕἘ-Ἕἠ-ὅὈ-Ὅὐ-ὗὙὛὝὟ-ώᾀ-ᾴᾶ-ᾼιῂ-ῄῆ-ῌῐ-ΐῖ-Ίῠ-Ῥῲ-ῴῶ-ῼⁱⁿₐ-ₜℂℇℊ-ℓℕℙ-ℝℤΩℨK-ℭℯ-ℹℼ-ℿⅅ-ⅉⅎⅠ-ↈⰀ-Ⱞⰰ-ⱞⱠ-ⳤⳫ-ⳮⳲⳳⴀ-ⴥⴧⴭⴰ-ⵧⵯⶀ-ⶖⶠ-ⶦⶨ-ⶮⶰ-ⶶⶸ-ⶾⷀ-ⷆⷈ-ⷎⷐ-ⷖⷘ-ⷞⸯ々-〇〡-〩〱-〵〸-〼ぁ-ゖゝ-ゟァ-ヺー-ヿㄅ-ㄭㄱ-ㆎㆠ-ㆺㇰ-ㇿ㐀-䶵一-鿌ꀀ-ꒌꓐ-ꓽꔀ-ꘌꘐ-ꘟꘪꘫꙀ-ꙮꙿ-ꚗꚠ-ꛯꜗ-ꜟꜢ-ꞈꞋ-ꞎꞐ-ꞓꞠ-Ɦꟸ-ꠁꠃ-ꠅꠇ-ꠊꠌ-ꠢꡀ-ꡳꢂ-ꢳꣲ-ꣷꣻꤊ-ꤥꤰ-ꥆꥠ-ꥼꦄ-ꦲꧏꨀ-ꨨꩀ-ꩂꩄ-ꩋꩠ-ꩶꩺꪀ-ꪯꪱꪵꪶꪹ-ꪽꫀꫂꫛ-ꫝꫠ-ꫪꫲ-ꫴꬁ-ꬆꬉ-ꬎꬑ-ꬖꬠ-ꬦꬨ-ꬮꯀ-ꯢ가-힣ힰ-ퟆퟋ-ퟻ豈-舘並-龎ff-stﬓ-ﬗיִײַ-ﬨשׁ-זּטּ-לּמּנּסּףּפּצּ-ﮱﯓ-ﴽﵐ-ﶏﶒ-ﷇﷰ-ﷻﹰ-ﹴﹶ-ﻼＡ-Ｚａ-ｚｦ-ﾾￂ-ￇￊ-ￏￒ-ￗￚ-ￜ]"),
+            NonAsciiIdentifierPart: new RegExp("[ªµºÀ-ÖØ-öø-ˁˆ-ˑˠ-ˤˬˮ̀-ʹͶͷͺ-ͽΆΈ-ΊΌΎ-ΡΣ-ϵϷ-ҁ҃-҇Ҋ-ԧԱ-Ֆՙա-և֑-ׇֽֿׁׂׅׄא-תװ-ײؐ-ؚؠ-٩ٮ-ۓە-ۜ۟-۪ۨ-ۼۿܐ-݊ݍ-ޱ߀-ߵߺࠀ-࠭ࡀ-࡛ࢠࢢ-ࢬࣤ-ࣾऀ-ॣ०-९ॱ-ॷॹ-ॿঁ-ঃঅ-ঌএঐও-নপ-রলশ-হ়-ৄেৈো-ৎৗড়ঢ়য়-ৣ০-ৱਁ-ਃਅ-ਊਏਐਓ-ਨਪ-ਰਲਲ਼ਵਸ਼ਸਹ਼ਾ-ੂੇੈੋ-੍ੑਖ਼-ੜਫ਼੦-ੵઁ-ઃઅ-ઍએ-ઑઓ-નપ-રલળવ-હ઼-ૅે-ૉો-્ૐૠ-ૣ૦-૯ଁ-ଃଅ-ଌଏଐଓ-ନପ-ରଲଳଵ-ହ଼-ୄେୈୋ-୍ୖୗଡ଼ଢ଼ୟ-ୣ୦-୯ୱஂஃஅ-ஊஎ-ஐஒ-கஙசஜஞடணதந-பம-ஹா-ூெ-ைொ-்ௐௗ௦-௯ఁ-ఃఅ-ఌఎ-ఐఒ-నప-ళవ-హఽ-ౄె-ైొ-్ౕౖౘౙౠ-ౣ౦-౯ಂಃಅ-ಌಎ-ಐಒ-ನಪ-ಳವ-ಹ಼-ೄೆ-ೈೊ-್ೕೖೞೠ-ೣ೦-೯ೱೲംഃഅ-ഌഎ-ഐഒ-ഺഽ-ൄെ-ൈൊ-ൎൗൠ-ൣ൦-൯ൺ-ൿංඃඅ-ඖක-නඳ-රලව-ෆ්ා-ුූෘ-ෟෲෳก-ฺเ-๎๐-๙ກຂຄງຈຊຍດ-ທນ-ຟມ-ຣລວສຫອ-ູົ-ຽເ-ໄໆ່-ໍ໐-໙ໜ-ໟༀ༘༙༠-༩༹༵༷༾-ཇཉ-ཬཱ-྄྆-ྗྙ-ྼ࿆က-၉ၐ-ႝႠ-ჅჇჍა-ჺჼ-ቈቊ-ቍቐ-ቖቘቚ-ቝበ-ኈኊ-ኍነ-ኰኲ-ኵኸ-ኾዀዂ-ዅወ-ዖዘ-ጐጒ-ጕጘ-ፚ፝-፟ᎀ-ᎏᎠ-Ᏼᐁ-ᙬᙯ-ᙿᚁ-ᚚᚠ-ᛪᛮ-ᛰᜀ-ᜌᜎ-᜔ᜠ-᜴ᝀ-ᝓᝠ-ᝬᝮ-ᝰᝲᝳក-៓ៗៜ៝០-៩᠋-᠍᠐-᠙ᠠ-ᡷᢀ-ᢪᢰ-ᣵᤀ-ᤜᤠ-ᤫᤰ-᤻᥆-ᥭᥰ-ᥴᦀ-ᦫᦰ-ᧉ᧐-᧙ᨀ-ᨛᨠ-ᩞ᩠-᩿᩼-᪉᪐-᪙ᪧᬀ-ᭋ᭐-᭙᭫-᭳ᮀ-᯳ᰀ-᰷᱀-᱉ᱍ-ᱽ᳐-᳔᳒-ᳶᴀ-ᷦ᷼-ἕἘ-Ἕἠ-ὅὈ-Ὅὐ-ὗὙὛὝὟ-ώᾀ-ᾴᾶ-ᾼιῂ-ῄῆ-ῌῐ-ΐῖ-Ίῠ-Ῥῲ-ῴῶ-ῼ‌‍‿⁀⁔ⁱⁿₐ-ₜ⃐-⃥⃜⃡-⃰ℂℇℊ-ℓℕℙ-ℝℤΩℨK-ℭℯ-ℹℼ-ℿⅅ-ⅉⅎⅠ-ↈⰀ-Ⱞⰰ-ⱞⱠ-ⳤⳫ-ⳳⴀ-ⴥⴧⴭⴰ-ⵧⵯ⵿-ⶖⶠ-ⶦⶨ-ⶮⶰ-ⶶⶸ-ⶾⷀ-ⷆⷈ-ⷎⷐ-ⷖⷘ-ⷞⷠ-ⷿⸯ々-〇〡-〯〱-〵〸-〼ぁ-ゖ゙゚ゝ-ゟァ-ヺー-ヿㄅ-ㄭㄱ-ㆎㆠ-ㆺㇰ-ㇿ㐀-䶵一-鿌ꀀ-ꒌꓐ-ꓽꔀ-ꘌꘐ-ꘫꙀ-꙯ꙴ-꙽ꙿ-ꚗꚟ-꛱ꜗ-ꜟꜢ-ꞈꞋ-ꞎꞐ-ꞓꞠ-Ɦꟸ-ꠧꡀ-ꡳꢀ-꣄꣐-꣙꣠-ꣷꣻ꤀-꤭ꤰ-꥓ꥠ-ꥼꦀ-꧀ꧏ-꧙ꨀ-ꨶꩀ-ꩍ꩐-꩙ꩠ-ꩶꩺꩻꪀ-ꫂꫛ-ꫝꫠ-ꫯꫲ-꫶ꬁ-ꬆꬉ-ꬎꬑ-ꬖꬠ-ꬦꬨ-ꬮꯀ-ꯪ꯬꯭꯰-꯹가-힣ힰ-ퟆퟋ-ퟻ豈-舘並-龎ff-stﬓ-ﬗיִ-ﬨשׁ-זּטּ-לּמּנּסּףּפּצּ-ﮱﯓ-ﴽﵐ-ﶏﶒ-ﷇﷰ-ﷻ︀-️︠-︦︳︴﹍-﹏ﹰ-ﹴﹶ-ﻼ０-９Ａ-Ｚ＿ａ-ｚｦ-ﾾￂ-ￇￊ-ￏￒ-ￗￚ-ￜ]")
+          };
+          function O(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 G(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 $(e) {
+            return e === 10 || e === 13 || e === 8232 || e === 8233;
+          }
+          function q(e) {
+            return e == 64 || e === 36 || e === 95 || // $ (dollar) and _ (underscore)
+            e >= 65 && e <= 90 || // A..Z
+            e >= 97 && e <= 122 || // a..z
+            e === 92 || // \ (backslash)
+            e >= 128 && o.NonAsciiIdentifierStart.test(String.fromCharCode(e));
+          }
+          function J(e) {
+            return e === 36 || e === 95 || // $ (dollar) and _ (underscore)
+            e >= 65 && e <= 90 || // A..Z
+            e >= 97 && e <= 122 || // a..z
+            e >= 48 && e <= 57 || // 0..9
+            e === 92 || // \ (backslash)
+            e >= 128 && o.NonAsciiIdentifierPart.test(String.fromCharCode(e));
+          }
+          function ce(e) {
+            switch (e) {
+              case "class":
+              case "enum":
+              case "export":
+              case "extends":
+              case "import":
+              case "super":
+                return !0;
+              default:
+                return !1;
+            }
+          }
+          function ee(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 Y(e) {
+            return e === "eval" || e === "arguments";
+          }
+          function fe(e) {
+            if (p && ee(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 oe(e, t, u, c, b) {
+            var I;
+            O(typeof u == "number", "Comment must have valid position"), !(y.lastCommentStart >= u) && (y.lastCommentStart = u, I = {
+              type: e,
+              value: t
+            }, m.range && (I.range = [u, c]), m.loc && (I.loc = b), m.comments.push(I), m.attachComment && (m.leadingComments.push(I), m.trailingComments.push(I)));
+          }
+          function pe(e) {
+            var t, u, c, b;
+            for (t = r - e, u = {
+              start: {
+                line: F,
+                column: r - w - e
+              }
+            }; r < g; )
+              if (c = s.charCodeAt(r), ++r, $(c)) {
+                m.comments && (b = s.slice(t + e, r - 1), u.end = {
+                  line: F,
+                  column: r - w - 1
+                }, oe("Line", b, t, r - 1, u)), c === 13 && s.charCodeAt(r) === 10 && ++r, ++F, w = r;
+                return;
+              }
+            m.comments && (b = s.slice(t + e, r), u.end = {
+              line: F,
+              column: r - w
+            }, oe("Line", b, t, r, u));
+          }
+          function Ie() {
+            var e, t, u, c;
+            for (m.comments && (e = r - 2, t = {
+              start: {
+                line: F,
+                column: r - w - 2
+              }
+            }); r < g; )
+              if (u = s.charCodeAt(r), $(u))
+                u === 13 && s.charCodeAt(r + 1) === 10 && ++r, ++F, ++r, w = r, r >= g && j({}, a.UnexpectedToken, "ILLEGAL");
+              else if (u === 42) {
+                if (s.charCodeAt(r + 1) === 47) {
+                  ++r, ++r, m.comments && (c = s.slice(e + 2, r - 2), t.end = {
+                    line: F,
+                    column: r - w
+                  }, oe("Block", c, e, r, t));
+                  return;
+                }
+                ++r;
+              } else
+                ++r;
+            j({}, a.UnexpectedToken, "ILLEGAL");
+          }
+          function v() {
+            var e, t;
+            for (t = r === 0; r < g; )
+              if (e = s.charCodeAt(r), G(e))
+                ++r;
+              else if ($(e))
+                ++r, e === 13 && s.charCodeAt(r) === 10 && ++r, ++F, w = r, t = !0;
+              else if (e === 47)
+                if (e = s.charCodeAt(r + 1), e === 47)
+                  ++r, ++r, pe(2), t = !0;
+                else if (e === 42)
+                  ++r, ++r, Ie();
+                else
+                  break;
+              else if (t && e === 45)
+                if (s.charCodeAt(r + 1) === 45 && s.charCodeAt(r + 2) === 62)
+                  r += 3, pe(3);
+                else
+                  break;
+              else if (e === 60)
+                if (s.slice(r + 1, r + 4) === "!--")
+                  ++r, ++r, ++r, ++r, pe(4);
+                else
+                  break;
+              else
+                break;
+          }
+          function B(e) {
+            var t, u, c, b = 0;
+            for (u = e === "u" ? 4 : 2, t = 0; t < u; ++t)
+              if (r < g && z(s[r]))
+                c = s[r++], b = b * 16 + "0123456789abcdef".indexOf(c.toLowerCase());
+              else
+                return "";
+            return String.fromCharCode(b);
+          }
+          function _() {
+            var e, t;
+            for (e = s.charCodeAt(r++), t = String.fromCharCode(e), e === 92 && (s.charCodeAt(r) !== 117 && j({}, a.UnexpectedToken, "ILLEGAL"), ++r, e = B("u"), (!e || e === "\\" || !q(e.charCodeAt(0))) && j({}, a.UnexpectedToken, "ILLEGAL"), t = e); r < g && (e = s.charCodeAt(r), !!J(e)); )
+              ++r, t += String.fromCharCode(e), e === 92 && (t = t.substr(0, t.length - 1), s.charCodeAt(r) !== 117 && j({}, a.UnexpectedToken, "ILLEGAL"), ++r, e = B("u"), (!e || e === "\\" || !J(e.charCodeAt(0))) && j({}, a.UnexpectedToken, "ILLEGAL"), t += e);
+            return t;
+          }
+          function K() {
+            var e, t;
+            for (e = r++; r < g; ) {
+              if (t = s.charCodeAt(r), t === 92)
+                return r = e, _();
+              if (J(t))
+                ++r;
+              else
+                break;
+            }
+            return s.slice(e, r);
+          }
+          function re() {
+            var e, t, u;
+            return e = r, t = s.charCodeAt(r) === 92 ? _() : K(), t.length === 1 ? u = l.Identifier : fe(t) ? u = l.Keyword : t === "null" ? u = l.NullLiteral : t === "true" || t === "false" ? u = l.BooleanLiteral : u = l.Identifier, {
+              type: u,
+              value: t,
+              lineNumber: F,
+              lineStart: w,
+              start: e,
+              end: r
+            };
+          }
+          function H() {
+            var e = r, t = s.charCodeAt(r), u, c = s[r], b, I, U;
+            switch (t) {
+              // Check for most common single-character punctuators.
+              case 46:
+              // . dot
+              case 40:
+              // ( open bracket
+              case 41:
+              // ) close bracket
+              case 59:
+              // ; semicolon
+              case 44:
+              // , comma
+              case 123:
+              // { open curly brace
+              case 125:
+              // } close curly brace
+              case 91:
+              // [
+              case 93:
+              // ]
+              case 58:
+              // :
+              case 63:
+              // ?
+              case 126:
+                return ++r, m.tokenize && (t === 40 ? m.openParenToken = m.tokens.length : t === 123 && (m.openCurlyToken = m.tokens.length)), {
+                  type: l.Punctuator,
+                  value: String.fromCharCode(t),
+                  lineNumber: F,
+                  lineStart: w,
+                  start: e,
+                  end: r
+                };
+              default:
+                if (u = s.charCodeAt(r + 1), u === 61)
+                  switch (t) {
+                    case 43:
+                    // +
+                    case 45:
+                    // -
+                    case 47:
+                    // /
+                    case 60:
+                    // <
+                    case 62:
+                    // >
+                    case 94:
+                    // ^
+                    case 124:
+                    // |
+                    case 37:
+                    // %
+                    case 38:
+                    // &
+                    case 42:
+                      return r += 2, {
+                        type: l.Punctuator,
+                        value: String.fromCharCode(t) + String.fromCharCode(u),
+                        lineNumber: F,
+                        lineStart: w,
+                        start: e,
+                        end: r
+                      };
+                    case 33:
+                    // !
+                    case 61:
+                      return r += 2, s.charCodeAt(r) === 61 && ++r, {
+                        type: l.Punctuator,
+                        value: s.slice(e, r),
+                        lineNumber: F,
+                        lineStart: w,
+                        start: e,
+                        end: r
+                      };
+                  }
+            }
+            if (U = s.substr(r, 4), U === ">>>=")
+              return r += 4, {
+                type: l.Punctuator,
+                value: U,
+                lineNumber: F,
+                lineStart: w,
+                start: e,
+                end: r
+              };
+            if (I = U.substr(0, 3), I === ">>>" || I === "<<=" || I === ">>=")
+              return r += 3, {
+                type: l.Punctuator,
+                value: I,
+                lineNumber: F,
+                lineStart: w,
+                start: e,
+                end: r
+              };
+            if (b = I.substr(0, 2), c === b[1] && "+-<>&|".indexOf(c) >= 0 || b === "=>")
+              return r += 2, {
+                type: l.Punctuator,
+                value: b,
+                lineNumber: F,
+                lineStart: w,
+                start: e,
+                end: r
+              };
+            if ("<>=!+-*%&|^/".indexOf(c) >= 0)
+              return ++r, {
+                type: l.Punctuator,
+                value: c,
+                lineNumber: F,
+                lineStart: w,
+                start: e,
+                end: r
+              };
+            j({}, a.UnexpectedToken, "ILLEGAL");
+          }
+          function W(e) {
+            for (var t = ""; r < g && z(s[r]); )
+              t += s[r++];
+            return t.length === 0 && j({}, a.UnexpectedToken, "ILLEGAL"), q(s.charCodeAt(r)) && j({}, a.UnexpectedToken, "ILLEGAL"), {
+              type: l.NumericLiteral,
+              value: parseInt("0x" + t, 16),
+              lineNumber: F,
+              lineStart: w,
+              start: e,
+              end: r
+            };
+          }
+          function Q(e) {
+            for (var t = "0" + s[r++]; r < g && T(s[r]); )
+              t += s[r++];
+            return (q(s.charCodeAt(r)) || M(s.charCodeAt(r))) && j({}, a.UnexpectedToken, "ILLEGAL"), {
+              type: l.NumericLiteral,
+              value: parseInt(t, 8),
+              octal: !0,
+              lineNumber: F,
+              lineStart: w,
+              start: e,
+              end: r
+            };
+          }
+          function Z() {
+            var e, t, u;
+            if (u = s[r], O(
+              M(u.charCodeAt(0)) || u === ".",
+              "Numeric literal must start with a decimal digit or a decimal point"
+            ), t = r, e = "", u !== ".") {
+              if (e = s[r++], u = s[r], e === "0") {
+                if (u === "x" || u === "X")
+                  return ++r, W(t);
+                if (T(u))
+                  return Q(t);
+                u && M(u.charCodeAt(0)) && j({}, a.UnexpectedToken, "ILLEGAL");
+              }
+              for (; M(s.charCodeAt(r)); )
+                e += s[r++];
+              u = s[r];
+            }
+            if (u === ".") {
+              for (e += s[r++]; M(s.charCodeAt(r)); )
+                e += s[r++];
+              u = s[r];
+            }
+            if (u === "e" || u === "E")
+              if (e += s[r++], u = s[r], (u === "+" || u === "-") && (e += s[r++]), M(s.charCodeAt(r)))
+                for (; M(s.charCodeAt(r)); )
+                  e += s[r++];
+              else
+                j({}, a.UnexpectedToken, "ILLEGAL");
+            return q(s.charCodeAt(r)) && j({}, a.UnexpectedToken, "ILLEGAL"), {
+              type: l.NumericLiteral,
+              value: parseFloat(e),
+              lineNumber: F,
+              lineStart: w,
+              start: t,
+              end: r
+            };
+          }
+          function me() {
+            var e = "", t, u, c, b, I, U, X = !1, ae, ue;
+            for (ae = F, ue = w, t = s[r], O(
+              t === "'" || t === '"',
+              "String literal must starts with a quote"
+            ), u = r, ++r; r < g; )
+              if (c = s[r++], c === t) {
+                t = "";
+                break;
+              } else if (c === "\\")
+                if (c = s[r++], !c || !$(c.charCodeAt(0)))
+                  switch (c) {
+                    case "u":
+                    case "x":
+                      U = r, I = B(c), I ? e += I : (r = U, e += c);
+                      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(c) ? (b = "01234567".indexOf(c), b !== 0 && (X = !0), r < g && T(s[r]) && (X = !0, b = b * 8 + "01234567".indexOf(s[r++]), "0123".indexOf(c) >= 0 && r < g && T(s[r]) && (b = b * 8 + "01234567".indexOf(s[r++]))), e += String.fromCharCode(b)) : e += c;
+                      break;
+                  }
+                else
+                  ++F, c === "\r" && s[r] === `
+` && ++r, w = r;
+              else {
+                if ($(c.charCodeAt(0)))
+                  break;
+                e += c;
+              }
+            return t !== "" && j({}, a.UnexpectedToken, "ILLEGAL"), {
+              type: l.StringLiteral,
+              value: e,
+              octal: X,
+              startLineNumber: ae,
+              startLineStart: ue,
+              lineNumber: F,
+              lineStart: w,
+              start: u,
+              end: r
+            };
+          }
+          function Se(e, t) {
+            var u;
+            try {
+              u = new RegExp(e, t);
+            } catch {
+              j({}, a.InvalidRegExp);
+            }
+            return u;
+          }
+          function Le() {
+            var e, t, u, c, b;
+            for (e = s[r], O(e === "/", "Regular expression literal must start with a slash"), t = s[r++], u = !1, c = !1; r < g; )
+              if (e = s[r++], t += e, e === "\\")
+                e = s[r++], $(e.charCodeAt(0)) && j({}, a.UnterminatedRegExp), t += e;
+              else if ($(e.charCodeAt(0)))
+                j({}, a.UnterminatedRegExp);
+              else if (u)
+                e === "]" && (u = !1);
+              else if (e === "/") {
+                c = !0;
+                break;
+              } else e === "[" && (u = !0);
+            return c || j({}, a.UnterminatedRegExp), b = t.substr(1, t.length - 2), {
+              value: b,
+              literal: t
+            };
+          }
+          function De() {
+            var e, t, u, c;
+            for (t = "", u = ""; r < g && (e = s[r], !!J(e.charCodeAt(0))); )
+              if (++r, e === "\\" && r < g)
+                if (e = s[r], e === "u") {
+                  if (++r, c = r, e = B("u"), e)
+                    for (u += e, t += "\\u"; c < r; ++c)
+                      t += s[c];
+                  else
+                    r = c, u += "u", t += "\\u";
+                  V({}, a.UnexpectedToken, "ILLEGAL");
+                } else
+                  t += "\\", V({}, a.UnexpectedToken, "ILLEGAL");
+              else
+                u += e, t += e;
+            return {
+              value: u,
+              literal: t
+            };
+          }
+          function _e() {
+            var e, t, u, c;
+            return i = null, v(), e = r, t = Le(), u = De(), c = Se(t.value, u.value), m.tokenize ? {
+              type: l.RegularExpression,
+              value: c,
+              lineNumber: F,
+              lineStart: w,
+              start: e,
+              end: r
+            } : {
+              literal: t.literal + u.literal,
+              value: c,
+              start: e,
+              end: r
+            };
+          }
+          function Ce() {
+            var e, t, u, c;
+            return v(), e = r, t = {
+              start: {
+                line: F,
+                column: r - w
+              }
+            }, u = _e(), t.end = {
+              line: F,
+              column: r - w
+            }, m.tokenize || (m.tokens.length > 0 && (c = m.tokens[m.tokens.length - 1], c.range[0] === e && c.type === "Punctuator" && (c.value === "/" || c.value === "/=") && m.tokens.pop()), m.tokens.push({
+              type: "RegularExpression",
+              value: u.literal,
+              range: [e, r],
+              loc: t
+            })), u;
+          }
+          function mt(e) {
+            return e.type === l.Identifier || e.type === l.Keyword || e.type === l.BooleanLiteral || e.type === l.NullLiteral;
+          }
+          function yt() {
+            var e, t;
+            if (e = m.tokens[m.tokens.length - 1], !e)
+              return Ce();
+            if (e.type === "Punctuator") {
+              if (e.value === "]")
+                return H();
+              if (e.value === ")")
+                return t = m.tokens[m.openParenToken - 1], t && t.type === "Keyword" && (t.value === "if" || t.value === "while" || t.value === "for" || t.value === "with") ? Ce() : H();
+              if (e.value === "}") {
+                if (m.tokens[m.openCurlyToken - 3] && m.tokens[m.openCurlyToken - 3].type === "Keyword") {
+                  if (t = m.tokens[m.openCurlyToken - 4], !t)
+                    return H();
+                } else if (m.tokens[m.openCurlyToken - 4] && m.tokens[m.openCurlyToken - 4].type === "Keyword") {
+                  if (t = m.tokens[m.openCurlyToken - 5], !t)
+                    return Ce();
+                } else
+                  return H();
+                return d.indexOf(t.value) >= 0 ? H() : Ce();
+              }
+              return Ce();
+            }
+            return e.type === "Keyword" ? Ce() : H();
+          }
+          function je() {
+            var e;
+            return v(), r >= g ? {
+              type: l.EOF,
+              lineNumber: F,
+              lineStart: w,
+              start: r,
+              end: r
+            } : (e = s.charCodeAt(r), q(e) ? re() : e === 40 || e === 41 || e === 59 ? H() : e === 39 || e === 34 ? me() : e === 46 ? M(s.charCodeAt(r + 1)) ? Z() : H() : M(e) ? Z() : m.tokenize && e === 47 ? yt() : H());
+          }
+          function We() {
+            var e, t, u;
+            return v(), e = {
+              start: {
+                line: F,
+                column: r - w
+              }
+            }, t = je(), e.end = {
+              line: F,
+              column: r - w
+            }, t.type !== l.EOF && (u = s.slice(t.start, t.end), m.tokens.push({
+              type: S[t.type],
+              value: u,
+              range: [t.start, t.end],
+              loc: e
+            })), t;
+          }
+          function L() {
+            var e;
+            return e = i, r = e.end, F = e.lineNumber, w = e.lineStart, i = typeof m.tokens < "u" ? We() : je(), r = e.end, F = e.lineNumber, w = e.lineStart, e;
+          }
+          function Me() {
+            var e, t, u;
+            e = r, t = F, u = w, i = typeof m.tokens < "u" ? We() : je(), r = e, F = t, w = u;
+          }
+          function Ve(e, t) {
+            this.line = e, this.column = t;
+          }
+          function dt(e, t, u, c) {
+            this.start = new Ve(e, t), this.end = new Ve(u, c);
+          }
+          A = {
+            name: "SyntaxTree",
+            processComment: function(e) {
+              var t, u;
+              if (!(e.type === f.Program && e.body.length > 0)) {
+                for (m.trailingComments.length > 0 ? m.trailingComments[0].range[0] >= e.range[1] ? (u = m.trailingComments, m.trailingComments = []) : m.trailingComments.length = 0 : m.bottomRightStack.length > 0 && m.bottomRightStack[m.bottomRightStack.length - 1].trailingComments && m.bottomRightStack[m.bottomRightStack.length - 1].trailingComments[0].range[0] >= e.range[1] && (u = m.bottomRightStack[m.bottomRightStack.length - 1].trailingComments, delete m.bottomRightStack[m.bottomRightStack.length - 1].trailingComments); m.bottomRightStack.length > 0 && m.bottomRightStack[m.bottomRightStack.length - 1].range[0] >= e.range[0]; )
+                  t = m.bottomRightStack.pop();
+                t ? t.leadingComments && t.leadingComments[t.leadingComments.length - 1].range[1] <= e.range[0] && (e.leadingComments = t.leadingComments, delete t.leadingComments) : m.leadingComments.length > 0 && m.leadingComments[m.leadingComments.length - 1].range[1] <= e.range[0] && (e.leadingComments = m.leadingComments, m.leadingComments = []), u && (e.trailingComments = u), m.bottomRightStack.push(e);
+              }
+            },
+            markEnd: function(e, t) {
+              return m.range && (e.range = [t.start, r]), m.loc && (e.loc = new dt(
+                t.startLineNumber === void 0 ? t.lineNumber : t.startLineNumber,
+                t.start - (t.startLineStart === void 0 ? t.lineStart : t.startLineStart),
+                F,
+                r - w
+              ), this.postProcess(e)), m.attachComment && this.processComment(e), e;
+            },
+            postProcess: function(e) {
+              return m.source && (e.loc.source = m.source), e;
+            },
+            createArrayExpression: function(e) {
+              return {
+                type: f.ArrayExpression,
+                elements: e
+              };
+            },
+            createAssignmentExpression: function(e, t, u) {
+              return {
+                type: f.AssignmentExpression,
+                operator: e,
+                left: t,
+                right: u
+              };
+            },
+            createBinaryExpression: function(e, t, u) {
+              var c = e === "||" || e === "&&" ? f.LogicalExpression : f.BinaryExpression;
+              return {
+                type: c,
+                operator: e,
+                left: t,
+                right: u
+              };
+            },
+            createBlockStatement: function(e) {
+              return {
+                type: f.BlockStatement,
+                body: e
+              };
+            },
+            createBreakStatement: function(e) {
+              return {
+                type: f.BreakStatement,
+                label: e
+              };
+            },
+            createCallExpression: function(e, t) {
+              return {
+                type: f.CallExpression,
+                callee: e,
+                arguments: t
+              };
+            },
+            createCatchClause: function(e, t) {
+              return {
+                type: f.CatchClause,
+                param: e,
+                body: t
+              };
+            },
+            createConditionalExpression: function(e, t, u) {
+              return {
+                type: f.ConditionalExpression,
+                test: e,
+                consequent: t,
+                alternate: u
+              };
+            },
+            createContinueStatement: function(e) {
+              return {
+                type: f.ContinueStatement,
+                label: e
+              };
+            },
+            createDebuggerStatement: function() {
+              return {
+                type: f.DebuggerStatement
+              };
+            },
+            createDoWhileStatement: function(e, t) {
+              return {
+                type: f.DoWhileStatement,
+                body: e,
+                test: t
+              };
+            },
+            createEmptyStatement: function() {
+              return {
+                type: f.EmptyStatement
+              };
+            },
+            createExpressionStatement: function(e) {
+              return {
+                type: f.ExpressionStatement,
+                expression: e
+              };
+            },
+            createForStatement: function(e, t, u, c) {
+              return {
+                type: f.ForStatement,
+                init: e,
+                test: t,
+                update: u,
+                body: c
+              };
+            },
+            createForInStatement: function(e, t, u) {
+              return {
+                type: f.ForInStatement,
+                left: e,
+                right: t,
+                body: u,
+                each: !1
+              };
+            },
+            createFunctionDeclaration: function(e, t, u, c) {
+              return {
+                type: f.FunctionDeclaration,
+                id: e,
+                params: t,
+                defaults: u,
+                body: c,
+                rest: null,
+                generator: !1,
+                expression: !1
+              };
+            },
+            createFunctionExpression: function(e, t, u, c) {
+              return {
+                type: f.FunctionExpression,
+                id: e,
+                params: t,
+                defaults: u,
+                body: c,
+                rest: null,
+                generator: !1,
+                expression: !1
+              };
+            },
+            createIdentifier: function(e) {
+              return {
+                type: f.Identifier,
+                name: e
+              };
+            },
+            createIfStatement: function(e, t, u) {
+              return {
+                type: f.IfStatement,
+                test: e,
+                consequent: t,
+                alternate: u
+              };
+            },
+            createLabeledStatement: function(e, t) {
+              return {
+                type: f.LabeledStatement,
+                label: e,
+                body: t
+              };
+            },
+            createLiteral: function(e) {
+              return {
+                type: f.Literal,
+                value: e.value,
+                raw: s.slice(e.start, e.end)
+              };
+            },
+            createMemberExpression: function(e, t, u) {
+              return {
+                type: f.MemberExpression,
+                computed: e === "[",
+                object: t,
+                property: u
+              };
+            },
+            createNewExpression: function(e, t) {
+              return {
+                type: f.NewExpression,
+                callee: e,
+                arguments: t
+              };
+            },
+            createObjectExpression: function(e) {
+              return {
+                type: f.ObjectExpression,
+                properties: e
+              };
+            },
+            createPostfixExpression: function(e, t) {
+              return {
+                type: f.UpdateExpression,
+                operator: e,
+                argument: t,
+                prefix: !1
+              };
+            },
+            createProgram: function(e) {
+              return {
+                type: f.Program,
+                body: e
+              };
+            },
+            createProperty: function(e, t, u) {
+              return {
+                type: f.Property,
+                key: t,
+                value: u,
+                kind: e
+              };
+            },
+            createReturnStatement: function(e) {
+              return {
+                type: f.ReturnStatement,
+                argument: e
+              };
+            },
+            createSequenceExpression: function(e) {
+              return {
+                type: f.SequenceExpression,
+                expressions: e
+              };
+            },
+            createSwitchCase: function(e, t) {
+              return {
+                type: f.SwitchCase,
+                test: e,
+                consequent: t
+              };
+            },
+            createSwitchStatement: function(e, t) {
+              return {
+                type: f.SwitchStatement,
+                discriminant: e,
+                cases: t
+              };
+            },
+            createThisExpression: function() {
+              return {
+                type: f.ThisExpression
+              };
+            },
+            createThrowStatement: function(e) {
+              return {
+                type: f.ThrowStatement,
+                argument: e
+              };
+            },
+            createTryStatement: function(e, t, u, c) {
+              return {
+                type: f.TryStatement,
+                block: e,
+                guardedHandlers: t,
+                handlers: u,
+                finalizer: c
+              };
+            },
+            createUnaryExpression: function(e, t) {
+              return e === "++" || e === "--" ? {
+                type: f.UpdateExpression,
+                operator: e,
+                argument: t,
+                prefix: !0
+              } : {
+                type: f.UnaryExpression,
+                operator: e,
+                argument: t,
+                prefix: !0
+              };
+            },
+            createVariableDeclaration: function(e, t) {
+              return {
+                type: f.VariableDeclaration,
+                declarations: e,
+                kind: t
+              };
+            },
+            createVariableDeclarator: function(e, t) {
+              return {
+                type: f.VariableDeclarator,
+                id: e,
+                init: t
+              };
+            },
+            createWhileStatement: function(e, t) {
+              return {
+                type: f.WhileStatement,
+                test: e,
+                body: t
+              };
+            },
+            createWithStatement: function(e, t) {
+              return {
+                type: f.WithStatement,
+                object: e,
+                body: t
+              };
+            }
+          };
+          function xe() {
+            var e, t, u, c;
+            return e = r, t = F, u = w, v(), c = F !== t, r = e, F = t, w = u, c;
+          }
+          function j(e, t) {
+            var u, c = Array.prototype.slice.call(arguments, 2), b = t.replace(
+              /%(\d)/g,
+              function(I, U) {
+                return O(U < c.length, "Message reference must be in range"), c[U];
+              }
+            );
+            throw typeof e.lineNumber == "number" ? (u = new Error("Line " + e.lineNumber + ": " + b), u.index = e.start, u.lineNumber = e.lineNumber, u.column = e.start - w + 1) : (u = new Error("Line " + F + ": " + b), u.index = r, u.lineNumber = F, u.column = r - w + 1), u.description = b, u;
+          }
+          function V() {
+            try {
+              j.apply(null, arguments);
+            } catch (e) {
+              if (m.errors)
+                m.errors.push(e);
+              else
+                throw e;
+            }
+          }
+          function ye(e) {
+            if (e.type === l.EOF && j(e, a.UnexpectedEOS), e.type === l.NumericLiteral && j(e, a.UnexpectedNumber), e.type === l.StringLiteral && j(e, a.UnexpectedString), e.type === l.Identifier && j(e, a.UnexpectedIdentifier), e.type === l.Keyword) {
+              if (ce(e.value))
+                j(e, a.UnexpectedReserved);
+              else if (p && ee(e.value)) {
+                V(e, a.StrictReservedWord);
+                return;
+              }
+              j(e, a.UnexpectedToken, e.value);
+            }
+            j(e, a.UnexpectedToken, e.value);
+          }
+          function R(e) {
+            var t = L();
+            (t.type !== l.Punctuator || t.value !== e) && ye(t);
+          }
+          function te(e) {
+            var t = L();
+            (t.type !== l.Keyword || t.value !== e) && ye(t);
+          }
+          function N(e) {
+            return i.type === l.Punctuator && i.value === e;
+          }
+          function ie(e) {
+            return i.type === l.Keyword && i.value === e;
+          }
+          function At() {
+            var e;
+            return i.type !== l.Punctuator ? !1 : (e = i.value, e === "=" || e === "*=" || e === "/=" || e === "%=" || e === "+=" || e === "-=" || e === "<<=" || e === ">>=" || e === ">>>=" || e === "&=" || e === "^=" || e === "|=");
+          }
+          function de() {
+            var e;
+            if (s.charCodeAt(r) === 59 || N(";")) {
+              L();
+              return;
+            }
+            e = F, v(), F === e && i.type !== l.EOF && !N("}") && ye(i);
+          }
+          function Oe(e) {
+            return e.type === f.Identifier || e.type === f.MemberExpression;
+          }
+          function Et() {
+            var e = [], t;
+            for (t = i, R("["); !N("]"); )
+              N(",") ? (L(), e.push(null)) : (e.push(he()), N("]") || R(","));
+            return L(), n.markEnd(n.createArrayExpression(e), t);
+          }
+          function Ue(e, t) {
+            var u, c, b;
+            return u = p, b = i, c = ze(), t && p && Y(e[0].name) && V(t, a.StrictParamName), p = u, n.markEnd(n.createFunctionExpression(null, e, [], c), b);
+          }
+          function Te() {
+            var e, t;
+            return t = i, e = L(), e.type === l.StringLiteral || e.type === l.NumericLiteral ? (p && e.octal && V(e, a.StrictOctalLiteral), n.markEnd(n.createLiteral(e), t)) : n.markEnd(n.createIdentifier(e.value), t);
+          }
+          function gt() {
+            var e, t, u, c, b, I;
+            if (e = i, I = i, e.type === l.Identifier)
+              return u = Te(), e.value === "get" && !N(":") ? (t = Te(), R("("), R(")"), c = Ue([]), n.markEnd(n.createProperty("get", t, c), I)) : e.value === "set" && !N(":") ? (t = Te(), R("("), e = i, e.type !== l.Identifier ? (R(")"), V(e, a.UnexpectedToken, e.value), c = Ue([])) : (b = [ge()], R(")"), c = Ue(b, e)), n.markEnd(n.createProperty("set", t, c), I)) : (R(":"), c = he(), n.markEnd(n.createProperty("init", u, c), I));
+            if (e.type === l.EOF || e.type === l.Punctuator)
+              ye(e);
+            else
+              return t = Te(), R(":"), c = he(), n.markEnd(n.createProperty("init", t, c), I);
+          }
+          function Ct() {
+            var e = [], t, u, c, b, I = {}, U = String, X;
+            for (X = i, R("{"); !N("}"); )
+              t = gt(), t.key.type === f.Identifier ? u = t.key.name : u = U(t.key.value), b = t.kind === "init" ? h.Data : t.kind === "get" ? h.Get : h.Set, c = "$" + u, Object.prototype.hasOwnProperty.call(I, c) ? (I[c] === h.Data ? p && b === h.Data ? V({}, a.StrictDuplicateProperty) : b !== h.Data && V({}, a.AccessorDataProperty) : b === h.Data ? V({}, a.AccessorDataProperty) : I[c] & b && V({}, a.AccessorGetSet), I[c] |= b) : I[c] = b, e.push(t), N("}") || R(",");
+            return R("}"), n.markEnd(n.createObjectExpression(e), X);
+          }
+          function vt() {
+            var e;
+            return R("("), e = ne(), R(")"), e;
+          }
+          function Xe() {
+            var e, t, u, c;
+            if (N("("))
+              return vt();
+            if (N("["))
+              return Et();
+            if (N("{"))
+              return Ct();
+            if (e = i.type, c = i, e === l.Identifier)
+              u = n.createIdentifier(L().value);
+            else if (e === l.StringLiteral || e === l.NumericLiteral)
+              p && i.octal && V(i, a.StrictOctalLiteral), u = n.createLiteral(L());
+            else if (e === l.Keyword) {
+              if (ie("function"))
+                return Xt();
+              ie("this") ? (L(), u = n.createThisExpression()) : ye(L());
+            } else e === l.BooleanLiteral ? (t = L(), t.value = t.value === "true", u = n.createLiteral(t)) : e === l.NullLiteral ? (t = L(), t.value = null, u = n.createLiteral(t)) : N("/") || N("/=") ? (typeof m.tokens < "u" ? u = n.createLiteral(Ce()) : u = n.createLiteral(_e()), Me()) : ye(L());
+            return n.markEnd(u, c);
+          }
+          function Ke() {
+            var e = [];
+            if (R("("), !N(")"))
+              for (; r < g && (e.push(he()), !N(")")); )
+                R(",");
+            return R(")"), e;
+          }
+          function St() {
+            var e, t;
+            return t = i, e = L(), mt(e) || ye(e), n.markEnd(n.createIdentifier(e.value), t);
+          }
+          function Je() {
+            return R("."), St();
+          }
+          function Qe() {
+            var e;
+            return R("["), e = ne(), R("]"), e;
+          }
+          function Ye() {
+            var e, t, u;
+            return u = i, te("new"), e = bt(), t = N("(") ? Ke() : [], n.markEnd(n.createNewExpression(e, t), u);
+          }
+          function Ft() {
+            var e, t, u, c, b;
+            for (b = i, e = y.allowIn, y.allowIn = !0, t = ie("new") ? Ye() : Xe(), y.allowIn = e; ; ) {
+              if (N("."))
+                c = Je(), t = n.createMemberExpression(".", t, c);
+              else if (N("("))
+                u = Ke(), t = n.createCallExpression(t, u);
+              else if (N("["))
+                c = Qe(), t = n.createMemberExpression("[", t, c);
+              else
+                break;
+              n.markEnd(t, b);
+            }
+            return t;
+          }
+          function bt() {
+            var e, t, u, c;
+            for (c = i, e = y.allowIn, t = ie("new") ? Ye() : Xe(), y.allowIn = e; N(".") || N("["); )
+              N("[") ? (u = Qe(), t = n.createMemberExpression("[", t, u)) : (u = Je(), t = n.createMemberExpression(".", t, u)), n.markEnd(t, c);
+            return t;
+          }
+          function Ze() {
+            var e, t, u = i;
+            return e = Ft(), i.type === l.Punctuator && (N("++") || N("--")) && !xe() && (p && e.type === f.Identifier && Y(e.name) && V({}, a.StrictLHSPostfix), Oe(e) || V({}, a.InvalidLHSInAssignment), t = L(), e = n.markEnd(n.createPostfixExpression(t.value, e), u)), e;
+          }
+          function Fe() {
+            var e, t, u;
+            return i.type !== l.Punctuator && i.type !== l.Keyword ? t = Ze() : N("++") || N("--") ? (u = i, e = L(), t = Fe(), p && t.type === f.Identifier && Y(t.name) && V({}, a.StrictLHSPrefix), Oe(t) || V({}, a.InvalidLHSInAssignment), t = n.createUnaryExpression(e.value, t), t = n.markEnd(t, u)) : N("+") || N("-") || N("~") || N("!") ? (u = i, e = L(), t = Fe(), t = n.createUnaryExpression(e.value, t), t = n.markEnd(t, u)) : ie("delete") || ie("void") || ie("typeof") ? (u = i, e = L(), t = Fe(), t = n.createUnaryExpression(e.value, t), t = n.markEnd(t, u), p && t.operator === "delete" && t.argument.type === f.Identifier && V({}, a.StrictDelete)) : t = Ze(), t;
+          }
+          function et(e, t) {
+            var u = 0;
+            if (e.type !== l.Punctuator && e.type !== l.Keyword)
+              return 0;
+            switch (e.value) {
+              case "||":
+                u = 1;
+                break;
+              case "&&":
+                u = 2;
+                break;
+              case "|":
+                u = 3;
+                break;
+              case "^":
+                u = 4;
+                break;
+              case "&":
+                u = 5;
+                break;
+              case "==":
+              case "!=":
+              case "===":
+              case "!==":
+                u = 6;
+                break;
+              case "<":
+              case ">":
+              case "<=":
+              case ">=":
+              case "instanceof":
+                u = 7;
+                break;
+              case "in":
+                u = t ? 7 : 0;
+                break;
+              case "<<":
+              case ">>":
+              case ">>>":
+                u = 8;
+                break;
+              case "+":
+              case "-":
+                u = 9;
+                break;
+              case "*":
+              case "/":
+              case "%":
+                u = 11;
+                break;
+            }
+            return u;
+          }
+          function Dt() {
+            var e, t, u, c, b, I, U, X, ae, ue;
+            if (e = i, ae = Fe(), c = i, b = et(c, y.allowIn), b === 0)
+              return ae;
+            for (c.prec = b, L(), t = [e, i], U = Fe(), I = [ae, c, U]; (b = et(i, y.allowIn)) > 0; ) {
+              for (; I.length > 2 && b <= I[I.length - 2].prec; )
+                U = I.pop(), X = I.pop().value, ae = I.pop(), u = n.createBinaryExpression(X, ae, U), t.pop(), e = t[t.length - 1], n.markEnd(u, e), I.push(u);
+              c = L(), c.prec = b, I.push(c), t.push(i), u = Fe(), I.push(u);
+            }
+            for (ue = I.length - 1, u = I[ue], t.pop(); ue > 1; )
+              u = n.createBinaryExpression(I[ue - 1].value, I[ue - 2], u), ue -= 2, e = t.pop(), n.markEnd(u, e);
+            return u;
+          }
+          function xt() {
+            var e, t, u, c, b;
+            return b = i, e = Dt(), N("?") && (L(), t = y.allowIn, y.allowIn = !0, u = he(), y.allowIn = t, R(":"), c = he(), e = n.createConditionalExpression(e, u, c), n.markEnd(e, b)), e;
+          }
+          function he() {
+            var e, t, u, c, b;
+            return e = i, b = i, c = t = xt(), At() && (Oe(t) || V({}, a.InvalidLHSInAssignment), p && t.type === f.Identifier && Y(t.name) && V(e, a.StrictLHSAssignment), e = L(), u = he(), c = n.markEnd(n.createAssignmentExpression(e.value, t, u), b)), c;
+          }
+          function ne() {
+            var e, t = i;
+            if (e = he(), N(",")) {
+              for (e = n.createSequenceExpression([e]); r < g && N(","); )
+                L(), e.expressions.push(he());
+              n.markEnd(e, t);
+            }
+            return e;
+          }
+          function Bt() {
+            for (var e = [], t; r < g && !(N("}") || (t = Be(), typeof t > "u")); )
+              e.push(t);
+            return e;
+          }
+          function Pe() {
+            var e, t;
+            return t = i, R("{"), e = Bt(), R("}"), n.markEnd(n.createBlockStatement(e), t);
+          }
+          function ge() {
+            var e, t;
+            return t = i, e = L(), e.type !== l.Identifier && ye(e), n.markEnd(n.createIdentifier(e.value), t);
+          }
+          function kt(e) {
+            var t = null, u, c;
+            return c = i, u = ge(), p && Y(u.name) && V({}, a.StrictVarName), e === "const" ? (R("="), t = he()) : N("=") && (L(), t = he()), n.markEnd(n.createVariableDeclarator(u, t), c);
+          }
+          function $e(e) {
+            var t = [];
+            do {
+              if (t.push(kt(e)), !N(","))
+                break;
+              L();
+            } while (r < g);
+            return t;
+          }
+          function wt() {
+            var e;
+            return te("var"), e = $e(), de(), n.createVariableDeclaration(e, "var");
+          }
+          function It(e) {
+            var t, u;
+            return u = i, te(e), t = $e(e), de(), n.markEnd(n.createVariableDeclaration(t, e), u);
+          }
+          function _t() {
+            return R(";"), n.createEmptyStatement();
+          }
+          function Ot() {
+            var e = ne();
+            return de(), n.createExpressionStatement(e);
+          }
+          function Tt() {
+            var e, t, u;
+            return te("if"), R("("), e = ne(), R(")"), t = Ae(), ie("else") ? (L(), u = Ae()) : u = null, n.createIfStatement(e, t, u);
+          }
+          function Pt() {
+            var e, t, u;
+            return te("do"), u = y.inIteration, y.inIteration = !0, e = Ae(), y.inIteration = u, te("while"), R("("), t = ne(), R(")"), N(";") && L(), n.createDoWhileStatement(e, t);
+          }
+          function Nt() {
+            var e, t, u;
+            return te("while"), R("("), e = ne(), R(")"), u = y.inIteration, y.inIteration = !0, t = Ae(), y.inIteration = u, n.createWhileStatement(e, t);
+          }
+          function Rt() {
+            var e, t, u;
+            return u = i, e = L(), t = $e(), n.markEnd(n.createVariableDeclaration(t, e.value), u);
+          }
+          function Lt() {
+            var e, t, u, c, b, I, U;
+            return e = t = u = null, te("for"), R("("), N(";") ? L() : (ie("var") || ie("let") ? (y.allowIn = !1, e = Rt(), y.allowIn = !0, e.declarations.length === 1 && ie("in") && (L(), c = e, b = ne(), e = null)) : (y.allowIn = !1, e = ne(), y.allowIn = !0, ie("in") && (Oe(e) || V({}, a.InvalidLHSInForIn), L(), c = e, b = ne(), e = null)), typeof c > "u" && R(";")), typeof c > "u" && (N(";") || (t = ne()), R(";"), N(")") || (u = ne())), R(")"), U = y.inIteration, y.inIteration = !0, I = Ae(), y.inIteration = U, typeof c > "u" ? n.createForStatement(e, t, u, I) : n.createForInStatement(c, b, I);
+          }
+          function jt() {
+            var e = null, t;
+            return te("continue"), s.charCodeAt(r) === 59 ? (L(), y.inIteration || j({}, a.IllegalContinue), n.createContinueStatement(null)) : xe() ? (y.inIteration || j({}, a.IllegalContinue), n.createContinueStatement(null)) : (i.type === l.Identifier && (e = ge(), t = "$" + e.name, Object.prototype.hasOwnProperty.call(y.labelSet, t) || j({}, a.UnknownLabel, e.name)), de(), e === null && !y.inIteration && j({}, a.IllegalContinue), n.createContinueStatement(e));
+          }
+          function Mt() {
+            var e = null, t;
+            return te("break"), s.charCodeAt(r) === 59 ? (L(), y.inIteration || y.inSwitch || j({}, a.IllegalBreak), n.createBreakStatement(null)) : xe() ? (y.inIteration || y.inSwitch || j({}, a.IllegalBreak), n.createBreakStatement(null)) : (i.type === l.Identifier && (e = ge(), t = "$" + e.name, Object.prototype.hasOwnProperty.call(y.labelSet, t) || j({}, a.UnknownLabel, e.name)), de(), e === null && !(y.inIteration || y.inSwitch) && j({}, a.IllegalBreak), n.createBreakStatement(e));
+          }
+          function Ut() {
+            var e = null;
+            return te("return"), y.inFunctionBody || V({}, a.IllegalReturn), s.charCodeAt(r) === 32 && q(s.charCodeAt(r + 1)) ? (e = ne(), de(), n.createReturnStatement(e)) : xe() ? n.createReturnStatement(null) : (N(";") || !N("}") && i.type !== l.EOF && (e = ne()), de(), n.createReturnStatement(e));
+          }
+          function $t() {
+            var e, t;
+            return p && (v(), V({}, a.StrictModeWith)), te("with"), R("("), e = ne(), R(")"), t = Ae(), n.createWithStatement(e, t);
+          }
+          function zt() {
+            var e, t = [], u, c;
+            for (c = i, ie("default") ? (L(), e = null) : (te("case"), e = ne()), R(":"); r < g && !(N("}") || ie("default") || ie("case")); )
+              u = Ae(), t.push(u);
+            return n.markEnd(n.createSwitchCase(e, t), c);
+          }
+          function Ht() {
+            var e, t, u, c, b;
+            if (te("switch"), R("("), e = ne(), R(")"), R("{"), t = [], N("}"))
+              return L(), n.createSwitchStatement(e, t);
+            for (c = y.inSwitch, y.inSwitch = !0, b = !1; r < g && !N("}"); )
+              u = zt(), u.test === null && (b && j({}, a.MultipleDefaultsInSwitch), b = !0), t.push(u);
+            return y.inSwitch = c, R("}"), n.createSwitchStatement(e, t);
+          }
+          function qt() {
+            var e;
+            return te("throw"), xe() && j({}, a.NewlineAfterThrow), e = ne(), de(), n.createThrowStatement(e);
+          }
+          function Gt() {
+            var e, t, u;
+            return u = i, te("catch"), R("("), N(")") && ye(i), e = ge(), p && Y(e.name) && V({}, a.StrictCatchVariable), R(")"), t = Pe(), n.markEnd(n.createCatchClause(e, t), u);
+          }
+          function Wt() {
+            var e, t = [], u = null;
+            return te("try"), e = Pe(), ie("catch") && t.push(Gt()), ie("finally") && (L(), u = Pe()), t.length === 0 && !u && j({}, a.NoCatchOrFinally), n.createTryStatement(e, [], t, u);
+          }
+          function Vt() {
+            return te("debugger"), de(), n.createDebuggerStatement();
+          }
+          function Ae() {
+            var e = i.type, t, u, c, b;
+            if (e === l.EOF && ye(i), e === l.Punctuator && i.value === "{")
+              return Pe();
+            if (b = i, e === l.Punctuator)
+              switch (i.value) {
+                case ";":
+                  return n.markEnd(_t(), b);
+                case "(":
+                  return n.markEnd(Ot(), b);
+              }
+            if (e === l.Keyword)
+              switch (i.value) {
+                case "break":
+                  return n.markEnd(Mt(), b);
+                case "continue":
+                  return n.markEnd(jt(), b);
+                case "debugger":
+                  return n.markEnd(Vt(), b);
+                case "do":
+                  return n.markEnd(Pt(), b);
+                case "for":
+                  return n.markEnd(Lt(), b);
+                case "function":
+                  return n.markEnd(rt(), b);
+                case "if":
+                  return n.markEnd(Tt(), b);
+                case "return":
+                  return n.markEnd(Ut(), b);
+                case "switch":
+                  return n.markEnd(Ht(), b);
+                case "throw":
+                  return n.markEnd(qt(), b);
+                case "try":
+                  return n.markEnd(Wt(), b);
+                case "var":
+                  return n.markEnd(wt(), b);
+                case "while":
+                  return n.markEnd(Nt(), b);
+                case "with":
+                  return n.markEnd($t(), b);
+              }
+            return t = ne(), t.type === f.Identifier && N(":") ? (L(), c = "$" + t.name, Object.prototype.hasOwnProperty.call(y.labelSet, c) && j({}, a.Redeclaration, "Label", t.name), y.labelSet[c] = !0, u = Ae(), delete y.labelSet[c], n.markEnd(n.createLabeledStatement(t, u), b)) : (de(), n.markEnd(n.createExpressionStatement(t), b));
+          }
+          function ze() {
+            var e, t = [], u, c, b, I, U, X, ae, ue;
+            for (ue = i, R("{"); r < g && !(i.type !== l.StringLiteral || (u = i, e = Be(), t.push(e), e.expression.type !== f.Literal)); )
+              c = s.slice(u.start + 1, u.end - 1), c === "use strict" ? (p = !0, b && V(b, a.StrictOctalLiteral)) : !b && u.octal && (b = u);
+            for (I = y.labelSet, U = y.inIteration, X = y.inSwitch, ae = y.inFunctionBody, y.labelSet = {}, y.inIteration = !1, y.inSwitch = !1, y.inFunctionBody = !0; r < g && !(N("}") || (e = Be(), typeof e > "u")); )
+              t.push(e);
+            return R("}"), y.labelSet = I, y.inIteration = U, y.inSwitch = X, y.inFunctionBody = ae, n.markEnd(n.createBlockStatement(t), ue);
+          }
+          function tt(e) {
+            var t, u = [], c, b, I, U, X;
+            if (R("("), !N(")"))
+              for (I = {}; r < g && (c = i, t = ge(), U = "$" + c.value, p ? (Y(c.value) && (b = c, X = a.StrictParamName), Object.prototype.hasOwnProperty.call(I, U) && (b = c, X = a.StrictParamDupe)) : e || (Y(c.value) ? (e = c, X = a.StrictParamName) : ee(c.value) ? (e = c, X = a.StrictReservedWord) : Object.prototype.hasOwnProperty.call(I, U) && (e = c, X = a.StrictParamDupe)), u.push(t), I[U] = !0, !N(")")); )
+                R(",");
+            return R(")"), {
+              params: u,
+              stricted: b,
+              firstRestricted: e,
+              message: X
+            };
+          }
+          function rt() {
+            var e, t = [], u, c, b, I, U, X, ae, ue;
+            return ue = i, te("function"), c = i, e = ge(), p ? Y(c.value) && V(c, a.StrictFunctionName) : Y(c.value) ? (U = c, X = a.StrictFunctionName) : ee(c.value) && (U = c, X = a.StrictReservedWord), I = tt(U), t = I.params, b = I.stricted, U = I.firstRestricted, I.message && (X = I.message), ae = p, u = ze(), p && U && j(U, X), p && b && V(b, X), p = ae, n.markEnd(n.createFunctionDeclaration(e, t, [], u), ue);
+          }
+          function Xt() {
+            var e, t = null, u, c, b, I, U = [], X, ae, ue;
+            return ue = i, te("function"), N("(") || (e = i, t = ge(), p ? Y(e.value) && V(e, a.StrictFunctionName) : Y(e.value) ? (c = e, b = a.StrictFunctionName) : ee(e.value) && (c = e, b = a.StrictReservedWord)), I = tt(c), U = I.params, u = I.stricted, c = I.firstRestricted, I.message && (b = I.message), ae = p, X = ze(), p && c && j(c, b), p && u && V(u, b), p = ae, n.markEnd(n.createFunctionExpression(t, U, [], X), ue);
+          }
+          function Be() {
+            if (i.type === l.Keyword)
+              switch (i.value) {
+                case "const":
+                case "let":
+                  return It(i.value);
+                case "function":
+                  return rt();
+                default:
+                  return Ae();
+              }
+            if (i.type !== l.EOF)
+              return Ae();
+          }
+          function Kt() {
+            for (var e, t = [], u, c, b; r < g && (u = i, !(u.type !== l.StringLiteral || (e = Be(), t.push(e), e.expression.type !== f.Literal))); )
+              c = s.slice(u.start + 1, u.end - 1), c === "use strict" ? (p = !0, b && V(b, a.StrictOctalLiteral)) : !b && u.octal && (b = u);
+            for (; r < g && (e = Be(), !(typeof e > "u")); )
+              t.push(e);
+            return t;
+          }
+          function Jt() {
+            var e, t;
+            return v(), Me(), t = i, p = !1, e = Kt(), n.markEnd(n.createProgram(e), t);
+          }
+          function nt() {
+            var e, t, u, c = [];
+            for (e = 0; e < m.tokens.length; ++e)
+              t = m.tokens[e], u = {
+                type: t.type,
+                value: t.value
+              }, m.range && (u.range = t.range), m.loc && (u.loc = t.loc), c.push(u);
+            m.tokens = c;
+          }
+          function Qt(e, t) {
+            var u, c, b;
+            u = String, typeof e != "string" && !(e instanceof String) && (e = u(e)), n = A, s = e, r = 0, F = s.length > 0 ? 1 : 0, w = 0, g = s.length, i = null, y = {
+              allowIn: !0,
+              labelSet: {},
+              inFunctionBody: !1,
+              inIteration: !1,
+              inSwitch: !1,
+              lastCommentStart: -1
+            }, m = {}, t = t || {}, t.tokens = !0, m.tokens = [], m.tokenize = !0, m.openParenToken = -1, m.openCurlyToken = -1, m.range = typeof t.range == "boolean" && t.range, m.loc = typeof t.loc == "boolean" && t.loc, typeof t.comment == "boolean" && t.comment && (m.comments = []), typeof t.tolerant == "boolean" && t.tolerant && (m.errors = []);
+            try {
+              if (Me(), i.type === l.EOF)
+                return m.tokens;
+              for (c = L(); i.type !== l.EOF; )
+                try {
+                  c = L();
+                } catch (I) {
+                  if (c = i, m.errors) {
+                    m.errors.push(I);
+                    break;
+                  } else
+                    throw I;
+                }
+              nt(), b = m.tokens, typeof m.comments < "u" && (b.comments = m.comments), typeof m.errors < "u" && (b.errors = m.errors);
+            } catch (I) {
+              throw I;
+            } finally {
+              m = {};
+            }
+            return b;
+          }
+          function Yt(e, t) {
+            var u, c;
+            c = String, typeof e != "string" && !(e instanceof String) && (e = c(e)), n = A, s = e, r = 0, F = s.length > 0 ? 1 : 0, w = 0, g = s.length, i = null, y = {
+              allowIn: !0,
+              labelSet: {},
+              inFunctionBody: !1,
+              inIteration: !1,
+              inSwitch: !1,
+              lastCommentStart: -1
+            }, m = {}, typeof t < "u" && (m.range = typeof t.range == "boolean" && t.range, m.loc = typeof t.loc == "boolean" && t.loc, m.attachComment = typeof t.attachComment == "boolean" && t.attachComment, m.loc && t.source !== null && t.source !== void 0 && (m.source = c(t.source)), typeof t.tokens == "boolean" && t.tokens && (m.tokens = []), typeof t.comment == "boolean" && t.comment && (m.comments = []), typeof t.tolerant == "boolean" && t.tolerant && (m.errors = []), m.attachComment && (m.range = !0, m.comments = [], m.bottomRightStack = [], m.trailingComments = [], m.leadingComments = []));
+            try {
+              u = Jt(), typeof m.comments < "u" && (u.comments = m.comments), typeof m.tokens < "u" && (nt(), u.tokens = m.tokens), typeof m.errors < "u" && (u.errors = m.errors);
+            } catch (b) {
+              throw b;
+            } finally {
+              m = {};
+            }
+            return u;
+          }
+          C.version = "1.2.2", C.tokenize = Qt, C.parse = Yt, C.Syntax = function() {
+            var e, t = {};
+            typeof Object.create == "function" && (t = /* @__PURE__ */ Object.create(null));
+            for (e in f)
+              f.hasOwnProperty(e) && (t[e] = f[e]);
+            return typeof Object.freeze == "function" && Object.freeze(t), t;
+          }();
+        });
+      }, {}], 1: [function(x, k, D) {
+        (function(C) {
+          var l = function() {
+            var S = {
+              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(o, A, s, p, r, F, w) {
+                p.ast || (p.ast = d, d.initialize());
+                var g = F.length - 1;
+                switch (r) {
+                  case 1:
+                    return p.ast.set({ expression: { type: "root", value: F[g] } }), p.ast.unshift(), p.ast.yield();
+                  case 2:
+                    return p.ast.set({ expression: { type: "root", value: F[g - 1] } }), p.ast.unshift(), p.ast.yield();
+                  case 3:
+                    return p.ast.unshift(), p.ast.yield();
+                  case 4:
+                    return p.ast.set({ operation: "member", scope: "child", expression: { type: "identifier", value: F[g - 1] } }), p.ast.unshift(), p.ast.yield();
+                  case 5:
+                    break;
+                  case 6:
+                    break;
+                  case 7:
+                    p.ast.set({ operation: "member" }), p.ast.push();
+                    break;
+                  case 8:
+                    p.ast.set({ operation: "subscript" }), p.ast.push();
+                    break;
+                  case 9:
+                    p.ast.set({ scope: "child" });
+                    break;
+                  case 10:
+                    p.ast.set({ scope: "descendant" });
+                    break;
+                  case 11:
+                    break;
+                  case 12:
+                    p.ast.set({ scope: "child", operation: "member" });
+                    break;
+                  case 13:
+                    break;
+                  case 14:
+                    p.ast.set({ expression: { type: "wildcard", value: F[g] } });
+                    break;
+                  case 15:
+                    p.ast.set({ expression: { type: "identifier", value: F[g] } });
+                    break;
+                  case 16:
+                    p.ast.set({ expression: { type: "script_expression", value: F[g] } });
+                    break;
+                  case 17:
+                    p.ast.set({ expression: { type: "numeric_literal", value: parseInt(F[g]) } });
+                    break;
+                  case 18:
+                    break;
+                  case 19:
+                    p.ast.set({ scope: "child" });
+                    break;
+                  case 20:
+                    p.ast.set({ scope: "descendant" });
+                    break;
+                  case 21:
+                    break;
+                  case 22:
+                    break;
+                  case 23:
+                    break;
+                  case 24:
+                    F[g].length > 1 ? p.ast.set({ expression: { type: "union", value: F[g] } }) : this.$ = F[g];
+                    break;
+                  case 25:
+                    this.$ = [F[g]];
+                    break;
+                  case 26:
+                    this.$ = F[g - 2].concat(F[g]);
+                    break;
+                  case 27:
+                    this.$ = { expression: { type: "numeric_literal", value: parseInt(F[g]) } }, p.ast.set(this.$);
+                    break;
+                  case 28:
+                    this.$ = { expression: { type: "string_literal", value: F[g] } }, p.ast.set(this.$);
+                    break;
+                  case 29:
+                    this.$ = { expression: { type: "slice", value: F[g] } }, p.ast.set(this.$);
+                    break;
+                  case 30:
+                    this.$ = { expression: { type: "wildcard", value: F[g] } }, p.ast.set(this.$);
+                    break;
+                  case 31:
+                    this.$ = { expression: { type: "script_expression", value: F[g] } }, p.ast.set(this.$);
+                    break;
+                  case 32:
+                    this.$ = { expression: { type: "filter_expression", value: F[g] } }, p.ast.set(this.$);
+                    break;
+                  case 33:
+                    this.$ = F[g];
+                    break;
+                  case 34:
+                    this.$ = F[g];
+                    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(o, A) {
+                if (A.recoverable)
+                  this.trace(o);
+                else
+                  throw new Error(o);
+              },
+              parse: function(o) {
+                var A = this, s = [0], p = [null], r = [], F = this.table, w = "", g = 0, n = 0, i = 2, y = 1, m = r.slice.call(arguments, 1);
+                this.lexer.setInput(o), this.lexer.yy = this.yy, this.yy.lexer = this.lexer, this.yy.parser = this, typeof this.lexer.yylloc > "u" && (this.lexer.yylloc = {});
+                var O = this.lexer.yylloc;
+                r.push(O);
+                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 pe;
+                  return pe = A.lexer.lex() || y, typeof pe != "number" && (pe = A.symbols_[pe] || pe), pe;
+                }
+                for (var T, G, $, q, J = {}, ce, ee, Y, fe; ; ) {
+                  if (G = s[s.length - 1], this.defaultActions[G] ? $ = this.defaultActions[G] : ((T === null || typeof T > "u") && (T = z()), $ = F[G] && F[G][T]), typeof $ > "u" || !$.length || !$[0]) {
+                    var oe = "";
+                    fe = [];
+                    for (ce in F[G])
+                      this.terminals_[ce] && ce > i && fe.push("'" + this.terminals_[ce] + "'");
+                    this.lexer.showPosition ? oe = "Parse error on line " + (g + 1) + `:
+` + this.lexer.showPosition() + `
+Expecting ` + fe.join(", ") + ", got '" + (this.terminals_[T] || T) + "'" : oe = "Parse error on line " + (g + 1) + ": Unexpected " + (T == y ? "end of input" : "'" + (this.terminals_[T] || T) + "'"), this.parseError(oe, {
+                      text: this.lexer.match,
+                      token: this.terminals_[T] || T,
+                      line: this.lexer.yylineno,
+                      loc: O,
+                      expected: fe
+                    });
+                  }
+                  if ($[0] instanceof Array && $.length > 1)
+                    throw new Error("Parse Error: multiple actions possible at state: " + G + ", token: " + T);
+                  switch ($[0]) {
+                    case 1:
+                      s.push(T), p.push(this.lexer.yytext), r.push(this.lexer.yylloc), s.push($[1]), T = null, n = this.lexer.yyleng, w = this.lexer.yytext, g = this.lexer.yylineno, O = this.lexer.yylloc;
+                      break;
+                    case 2:
+                      if (ee = this.productions_[$[1]][1], J.$ = p[p.length - ee], J._$ = {
+                        first_line: r[r.length - (ee || 1)].first_line,
+                        last_line: r[r.length - 1].last_line,
+                        first_column: r[r.length - (ee || 1)].first_column,
+                        last_column: r[r.length - 1].last_column
+                      }, M && (J._$.range = [
+                        r[r.length - (ee || 1)].range[0],
+                        r[r.length - 1].range[1]
+                      ]), q = this.performAction.apply(J, [
+                        w,
+                        n,
+                        g,
+                        this.yy,
+                        $[1],
+                        p,
+                        r
+                      ].concat(m)), typeof q < "u")
+                        return q;
+                      ee && (s = s.slice(0, -1 * ee * 2), p = p.slice(0, -1 * ee), r = r.slice(0, -1 * ee)), s.push(this.productions_[$[1]][0]), p.push(J.$), r.push(J._$), Y = F[s[s.length - 2]][s[s.length - 1]], s.push(Y);
+                      break;
+                    case 3:
+                      return !0;
+                  }
+                }
+                return !0;
+              }
+            }, d = {
+              initialize: function() {
+                this._nodes = [], this._node = {}, this._stash = [];
+              },
+              set: function(a) {
+                for (var o in a) this._node[o] = a[o];
+                return this._node;
+              },
+              node: function(a) {
+                return arguments.length && (this._node = a), this._node;
+              },
+              push: function() {
+                this._nodes.push(this._node), this._node = {};
+              },
+              unshift: function() {
+                this._nodes.unshift(this._node), this._node = {};
+              },
+              yield: function() {
+                var a = this._nodes;
+                return this.initialize(), a;
+              }
+            }, f = /* @__PURE__ */ function() {
+              var a = {
+                EOF: 1,
+                parseError: function(A, s) {
+                  if (this.yy.parser)
+                    this.yy.parser.parseError(A, s);
+                  else
+                    throw new Error(A);
+                },
+                // resets the lexer, sets new input
+                setInput: function(o) {
+                  return this._input = o, 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 o = this._input[0];
+                  this.yytext += o, this.yyleng++, this.offset++, this.match += o, this.matched += o;
+                  var A = o.match(/(?:\r\n?|\n).*/g);
+                  return A ? (this.yylineno++, this.yylloc.last_line++) : this.yylloc.last_column++, this.options.ranges && this.yylloc.range[1]++, this._input = this._input.slice(1), o;
+                },
+                // unshifts one char (or a string) into the input
+                unput: function(o) {
+                  var A = o.length, s = o.split(/(?:\r\n?|\n)/g);
+                  this._input = o + this._input, this.yytext = this.yytext.substr(0, this.yytext.length - A - 1), this.offset -= A;
+                  var p = 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), s.length - 1 && (this.yylineno -= s.length - 1);
+                  var r = 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: s ? (s.length === p.length ? this.yylloc.first_column : 0) + p[p.length - s.length].length - s[0].length : this.yylloc.first_column - A
+                  }, this.options.ranges && (this.yylloc.range = [r[0], r[0] + this.yyleng - A]), 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(o) {
+                  this.unput(this.match.slice(o));
+                },
+                // displays already matched input, i.e. for error messages
+                pastInput: function() {
+                  var o = this.matched.substr(0, this.matched.length - this.match.length);
+                  return (o.length > 20 ? "..." : "") + o.substr(-20).replace(/\n/g, "");
+                },
+                // displays upcoming input, i.e. for error messages
+                upcomingInput: function() {
+                  var o = this.match;
+                  return o.length < 20 && (o += this._input.substr(0, 20 - o.length)), (o.substr(0, 20) + (o.length > 20 ? "..." : "")).replace(/\n/g, "");
+                },
+                // displays the character position where the lexing error occurred, i.e. for error messages
+                showPosition: function() {
+                  var o = this.pastInput(), A = new Array(o.length + 1).join("-");
+                  return o + this.upcomingInput() + `
+` + A + "^";
+                },
+                // test the lexed token: return FALSE when not a match, otherwise return token
+                test_match: function(o, A) {
+                  var s, p, r;
+                  if (this.options.backtrack_lexer && (r = {
+                    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 && (r.yylloc.range = this.yylloc.range.slice(0))), p = o[0].match(/(?:\r\n?|\n).*/g), p && (this.yylineno += p.length), this.yylloc = {
+                    first_line: this.yylloc.last_line,
+                    last_line: this.yylineno + 1,
+                    first_column: this.yylloc.last_column,
+                    last_column: p ? p[p.length - 1].length - p[p.length - 1].match(/\r?\n?/)[0].length : this.yylloc.last_column + o[0].length
+                  }, this.yytext += o[0], this.match += o[0], this.matches = o, 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(o[0].length), this.matched += o[0], s = this.performAction.call(this, this.yy, this, A, this.conditionStack[this.conditionStack.length - 1]), this.done && this._input && (this.done = !1), s)
+                    return s;
+                  if (this._backtrack) {
+                    for (var F in r)
+                      this[F] = r[F];
+                    return !1;
+                  }
+                  return !1;
+                },
+                // return next match in input
+                next: function() {
+                  if (this.done)
+                    return this.EOF;
+                  this._input || (this.done = !0);
+                  var o, A, s, p;
+                  this._more || (this.yytext = "", this.match = "");
+                  for (var r = this._currentRules(), F = 0; F < r.length; F++)
+                    if (s = this._input.match(this.rules[r[F]]), s && (!A || s[0].length > A[0].length)) {
+                      if (A = s, p = F, this.options.backtrack_lexer) {
+                        if (o = this.test_match(s, r[F]), o !== !1)
+                          return o;
+                        if (this._backtrack) {
+                          A = !1;
+                          continue;
+                        } else
+                          return !1;
+                      } else if (!this.options.flex)
+                        break;
+                    }
+                  return A ? (o = this.test_match(A, r[p]), o !== !1 ? o : !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 A = this.next();
+                  return A || this.lex();
+                },
+                // activates a new lexer condition state (pushes the new lexer condition state onto the condition stack)
+                begin: function(A) {
+                  this.conditionStack.push(A);
+                },
+                // pop the previously active lexer condition state off the condition stack
+                popState: function() {
+                  var A = this.conditionStack.length - 1;
+                  return A > 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(A) {
+                  return A = this.conditionStack.length - 1 - Math.abs(A || 0), A >= 0 ? this.conditionStack[A] : "INITIAL";
+                },
+                // alias for begin(condition)
+                pushState: function(A) {
+                  this.begin(A);
+                },
+                // return the number of states currently on the stack
+                stateStackSize: function() {
+                  return this.conditionStack.length;
+                },
+                options: {},
+                performAction: function(A, s, p, r) {
+                  switch (p) {
+                    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 s.yytext = s.yytext.substr(1, s.yyleng - 2), 32;
+                    case 11:
+                      return s.yytext = s.yytext.substr(1, s.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 a;
+            }();
+            S.lexer = f;
+            function h() {
+              this.yy = {};
+            }
+            return h.prototype = S, S.Parser = h, new h();
+          }();
+          typeof x < "u" && typeof D < "u" && (D.parser = l, D.Parser = l.Parser, D.parse = function() {
+            return l.parse.apply(l, arguments);
+          }, D.main = function(d) {
+            d[1] || (console.log("Usage: " + d[0] + " FILE"), C.exit(1));
+            var f = x("fs").readFileSync(x("path").normalize(d[1]), "utf8");
+            return D.parser.parse(f);
+          }, typeof k < "u" && x.main === k && D.main(C.argv.slice(1)));
+        }).call(this, x("_process"));
+      }, { _process: 14, fs: 12, path: 13 }], 2: [function(x, k, D) {
+        k.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(x, k, D) {
+        var C = x("./dict"), l = x("fs"), S = {
+          lex: {
+            macros: {
+              esc: "\\\\",
+              int: C.integer
+            },
+            rules: [
+              ["\\$", "return 'DOLLAR'"],
+              ["\\.\\.", "return 'DOT_DOT'"],
+              ["\\.", "return 'DOT'"],
+              ["\\*", "return 'STAR'"],
+              [C.identifier, "return 'IDENTIFIER'"],
+              ["\\[", "return '['"],
+              ["\\]", "return ']'"],
+              [",", "return ','"],
+              ["({int})?\\:({int})?(\\:({int})?)?", "return 'ARRAY_SLICE'"],
+              ["{int}", "return 'INTEGER'"],
+              [C.qq_string, "yytext = yytext.substr(1,yyleng-2); return 'QQ_STRING';"],
+              [C.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"]
+            ]
+          }
+        };
+        l.readFileSync && (S.moduleInclude = l.readFileSync(x.resolve("../include/module.js")), S.actionInclude = l.readFileSync(x.resolve("../include/action.js"))), k.exports = S;
+      }, { "./dict": 2, fs: 12 }], 4: [function(x, k, D) {
+        var C = x("./aesprim"), l = x("./slice"), S = x("static-eval"), d = x("underscore").uniq, f = function() {
+          return this.initialize.apply(this, arguments);
+        };
+        f.prototype.initialize = function() {
+          this.traverse = A(!0), this.descend = A();
+        }, f.prototype.keys = Object.keys, f.prototype.resolve = function(g) {
+          var n = [g.operation, g.scope, g.expression.type].join("-"), i = this._fns[n];
+          if (!i) throw new Error("couldn't resolve key: " + n);
+          return i.bind(this);
+        }, f.prototype.register = function(g, n) {
+          if (!n instanceof Function)
+            throw new Error("handler must be a function");
+          this._fns[g] = n;
+        }, f.prototype._fns = {
+          "member-child-identifier": function(g, n) {
+            var i = g.expression.value, y = n.value;
+            if (y instanceof Object && i in y)
+              return [{ value: y[i], path: n.path.concat(i) }];
+          },
+          "member-descendant-identifier": p(function(g, n, i) {
+            return g == i;
+          }),
+          "subscript-child-numeric_literal": s(function(g, n, i) {
+            return g === i;
+          }),
+          "member-child-numeric_literal": s(function(g, n, i) {
+            return String(g) === String(i);
+          }),
+          "subscript-descendant-numeric_literal": p(function(g, n, i) {
+            return g === i;
+          }),
+          "member-child-wildcard": s(function() {
+            return !0;
+          }),
+          "member-descendant-wildcard": p(function() {
+            return !0;
+          }),
+          "subscript-descendant-wildcard": p(function() {
+            return !0;
+          }),
+          "subscript-child-wildcard": s(function() {
+            return !0;
+          }),
+          "subscript-child-slice": function(g, n) {
+            if (a(n.value)) {
+              var i = g.expression.value.split(":").map(w), y = n.value.map(function(m, O) {
+                return { value: m, path: n.path.concat(O) };
+              });
+              return l.apply(null, [y].concat(i));
+            }
+          },
+          "subscript-child-union": function(g, n) {
+            var i = [];
+            return g.expression.value.forEach(function(y) {
+              var m = { operation: "subscript", scope: "child", expression: y.expression }, O = this.resolve(m), M = O(m, n);
+              M && (i = i.concat(M));
+            }, this), F(i);
+          },
+          "subscript-descendant-union": function(g, n, i) {
+            var y = x(".."), m = this, O = [], M = y.nodes(n, "$..*").slice(1);
+            return M.forEach(function(z) {
+              O.length >= i || g.expression.value.forEach(function(T) {
+                var G = { operation: "subscript", scope: "child", expression: T.expression }, $ = m.resolve(G), q = $(G, z);
+                O = O.concat(q);
+              });
+            }), F(O);
+          },
+          "subscript-child-filter_expression": function(g, n, i) {
+            var y = g.expression.value.slice(2, -1), m = C.parse(y).body[0].expression, O = function(M, z) {
+              return r(m, { "@": z });
+            };
+            return this.descend(n, null, O, i);
+          },
+          "subscript-descendant-filter_expression": function(g, n, i) {
+            var y = g.expression.value.slice(2, -1), m = C.parse(y).body[0].expression, O = function(M, z) {
+              return r(m, { "@": z });
+            };
+            return this.traverse(n, null, O, i);
+          },
+          "subscript-child-script_expression": function(g, n) {
+            var i = g.expression.value.slice(1, -1);
+            return h(n, i, "$[{{value}}]");
+          },
+          "member-child-script_expression": function(g, n) {
+            var i = g.expression.value.slice(1, -1);
+            return h(n, i, "$.{{value}}");
+          },
+          "member-descendant-script_expression": function(g, n) {
+            var i = g.expression.value.slice(1, -1);
+            return h(n, i, "$..value");
+          }
+        }, f.prototype._fns["subscript-child-string_literal"] = f.prototype._fns["member-child-identifier"], f.prototype._fns["member-descendant-numeric_literal"] = f.prototype._fns["subscript-descendant-string_literal"] = f.prototype._fns["member-descendant-identifier"];
+        function h(g, n, i) {
+          var y = x("./index"), m = C.parse(n).body[0].expression, O = r(m, { "@": g.value }), M = i.replace(/\{\{\s*value\s*\}\}/g, O), z = y.nodes(g.value, M);
+          return z.forEach(function(T) {
+            T.path = g.path.concat(T.path.slice(1));
+          }), z;
+        }
+        function a(g) {
+          return Array.isArray(g);
+        }
+        function o(g) {
+          return g && !(g instanceof Array) && g instanceof Object;
+        }
+        function A(g) {
+          return function(n, i, y, m) {
+            var O = n.value, M = n.path, z = [], T = (function(G, $) {
+              a(G) ? (G.forEach(function(q, J) {
+                z.length >= m || y(J, q, i) && z.push({ path: $.concat(J), value: q });
+              }), G.forEach(function(q, J) {
+                z.length >= m || g && T(q, $.concat(J));
+              })) : o(G) && (this.keys(G).forEach(function(q) {
+                z.length >= m || y(q, G[q], i) && z.push({ path: $.concat(q), value: G[q] });
+              }), this.keys(G).forEach(function(q) {
+                z.length >= m || g && T(G[q], $.concat(q));
+              }));
+            }).bind(this);
+            return T(O, M), z;
+          };
+        }
+        function s(g) {
+          return function(n, i, y) {
+            return this.descend(i, n.expression.value, g, y);
+          };
+        }
+        function p(g) {
+          return function(n, i, y) {
+            return this.traverse(i, n.expression.value, g, y);
+          };
+        }
+        function r() {
+          try {
+            return S.apply(this, arguments);
+          } catch {
+          }
+        }
+        function F(g) {
+          return g = g.filter(function(n) {
+            return n;
+          }), d(
+            g,
+            function(n) {
+              return n.path.map(function(i) {
+                return String(i).replace("-", "--");
+              }).join("-");
+            }
+          );
+        }
+        function w(g) {
+          var n = String(g);
+          return n.match(/^-?[0-9]+$/) ? parseInt(n) : null;
+        }
+        k.exports = f;
+      }, { "..": "jsonpath", "./aesprim": "./aesprim", "./index": 5, "./slice": 7, "static-eval": 15, underscore: 12 }], 5: [function(x, k, D) {
+        var C = x("assert"), l = x("./dict"), S = x("./parser"), d = x("./handlers"), f = function() {
+          this.initialize.apply(this, arguments);
+        };
+        f.prototype.initialize = function() {
+          this.parser = new S(), this.handlers = new d();
+        }, f.prototype.parse = function(o) {
+          return C.ok(h(o), "we need a path"), this.parser.parse(o);
+        }, f.prototype.parent = function(o, A) {
+          C.ok(o instanceof Object, "obj needs to be an object"), C.ok(A, "we need a path");
+          var s = this.nodes(o, A)[0];
+          return s.path.pop(), this.value(o, s.path);
+        }, f.prototype.apply = function(o, A, s) {
+          C.ok(o instanceof Object, "obj needs to be an object"), C.ok(A, "we need a path"), C.equal(typeof s, "function", "fn needs to be function");
+          var p = this.nodes(o, A).sort(function(r, F) {
+            return F.path.length - r.path.length;
+          });
+          return p.forEach(function(r) {
+            var F = r.path.pop(), w = this.value(o, this.stringify(r.path)), g = r.value = s.call(o, w[F]);
+            w[F] = g;
+          }, this), p;
+        }, f.prototype.value = function(o, A, s) {
+          if (C.ok(o instanceof Object, "obj needs to be an object"), C.ok(A, "we need a path"), arguments.length >= 3) {
+            var p = this.nodes(o, A).shift();
+            if (!p) return this._vivify(o, A, s);
+            var r = p.path.slice(-1).shift(), F = this.parent(o, this.stringify(p.path));
+            F[r] = s;
+          }
+          return this.query(o, this.stringify(A), 1).shift();
+        }, f.prototype._vivify = function(o, A, s) {
+          var p = this;
+          C.ok(o instanceof Object, "obj needs to be an object"), C.ok(A, "we need a path");
+          var r = this.parser.parse(A).map(function(w) {
+            return w.expression.value;
+          }), F = function(w, g) {
+            var n = w.pop(), i = p.value(o, w);
+            i || (F(w.concat(), typeof n == "string" ? {} : []), i = p.value(o, w)), i[n] = g;
+          };
+          return F(r, s), this.query(o, A)[0];
+        }, f.prototype.query = function(o, A, s) {
+          C.ok(o instanceof Object, "obj needs to be an object"), C.ok(h(A), "we need a path");
+          var p = this.nodes(o, A, s).map(function(r) {
+            return r.value;
+          });
+          return p;
+        }, f.prototype.paths = function(o, A, s) {
+          C.ok(o instanceof Object, "obj needs to be an object"), C.ok(A, "we need a path");
+          var p = this.nodes(o, A, s).map(function(r) {
+            return r.path;
+          });
+          return p;
+        }, f.prototype.nodes = function(o, A, s) {
+          if (C.ok(o instanceof Object, "obj needs to be an object"), C.ok(A, "we need a path"), s === 0) return [];
+          var p = this.parser.parse(A), r = this.handlers, F = [{ path: ["$"], value: o }], w = [];
+          return p.length && p[0].expression.type == "root" && p.shift(), p.length ? (p.forEach(function(g, n) {
+            if (!(w.length >= s)) {
+              var i = r.resolve(g), y = [];
+              F.forEach(function(m) {
+                if (!(w.length >= s)) {
+                  var O = i(g, m, s);
+                  n == p.length - 1 ? w = w.concat(O || []) : y = y.concat(O || []);
+                }
+              }), F = y;
+            }
+          }), s ? w.slice(0, s) : w) : F;
+        }, f.prototype.stringify = function(o) {
+          C.ok(o, "we need a path");
+          var A = "$", s = {
+            "descendant-member": "..{{value}}",
+            "child-member": ".{{value}}",
+            "descendant-subscript": "..[{{value}}]",
+            "child-subscript": "[{{value}}]"
+          };
+          return o = this._normalize(o), o.forEach(function(p) {
+            if (p.expression.type != "root") {
+              var r = [p.scope, p.operation].join("-"), F = s[r], w;
+              if (p.expression.type == "string_literal" ? w = JSON.stringify(p.expression.value) : w = p.expression.value, !F) throw new Error("couldn't find template " + r);
+              A += F.replace(/{{value}}/, w);
+            }
+          }), A;
+        }, f.prototype._normalize = function(o) {
+          if (C.ok(o, "we need a path"), typeof o == "string")
+            return this.parser.parse(o);
+          if (Array.isArray(o) && typeof o[0] == "string") {
+            var A = [{ expression: { type: "root", value: "$" } }];
+            return o.forEach(function(s, p) {
+              if (!(s == "$" && p === 0))
+                if (typeof s == "string" && s.match("^" + l.identifier + "$"))
+                  A.push({
+                    operation: "member",
+                    scope: "child",
+                    expression: { value: s, type: "identifier" }
+                  });
+                else {
+                  var r = typeof s == "number" ? "numeric_literal" : "string_literal";
+                  A.push({
+                    operation: "subscript",
+                    scope: "child",
+                    expression: { value: s, type: r }
+                  });
+                }
+            }), A;
+          } else if (Array.isArray(o) && typeof o[0] == "object")
+            return o;
+          throw new Error("couldn't understand path " + o);
+        };
+        function h(o) {
+          return Object.prototype.toString.call(o) == "[object String]";
+        }
+        f.Handlers = d, f.Parser = S;
+        var a = new f();
+        a.JSONPath = f, k.exports = a;
+      }, { "./dict": 2, "./handlers": 4, "./parser": 6, assert: 8 }], 6: [function(x, k, D) {
+        var C = x("./grammar"), l = x("../generated/parser"), S = function() {
+          var d = new l.Parser(), f = d.parseError;
+          return d.yy.parseError = function() {
+            d.yy.ast && d.yy.ast.initialize(), f.apply(d, arguments);
+          }, d;
+        };
+        S.grammar = C, k.exports = S;
+      }, { "../generated/parser": 1, "./grammar": 3 }], 7: [function(x, k, D) {
+        k.exports = function(l, S, d, f) {
+          if (typeof S == "string") throw new Error("start cannot be a string");
+          if (typeof d == "string") throw new Error("end cannot be a string");
+          if (typeof f == "string") throw new Error("step cannot be a string");
+          var h = l.length;
+          if (f === 0) throw new Error("step cannot be zero");
+          if (f = f ? C(f) : 1, S = S < 0 ? h + S : S, d = d < 0 ? h + d : d, S = C(S === 0 ? 0 : S || (f > 0 ? 0 : h - 1)), d = C(d === 0 ? 0 : d || (f > 0 ? h : -1)), S = f > 0 ? Math.max(0, S) : Math.min(h, S), d = f > 0 ? Math.min(d, h) : Math.max(-1, d), f > 0 && d <= S) return [];
+          if (f < 0 && S <= d) return [];
+          for (var a = [], o = S; o != d && !(f < 0 && o <= d || f > 0 && o >= d); o += f)
+            a.push(l[o]);
+          return a;
+        };
+        function C(l) {
+          return String(l).match(/^[0-9]+$/) ? parseInt(l) : Number.isFinite(l) ? parseInt(l, 10) : 0;
+        }
+      }, {}], 8: [function(x, k, D) {
+        var C = x("util/"), l = Array.prototype.slice, S = Object.prototype.hasOwnProperty, d = k.exports = A;
+        d.AssertionError = function(i) {
+          this.name = "AssertionError", this.actual = i.actual, this.expected = i.expected, this.operator = i.operator, i.message ? (this.message = i.message, this.generatedMessage = !1) : (this.message = a(this), this.generatedMessage = !0);
+          var y = i.stackStartFunction || o;
+          if (Error.captureStackTrace)
+            Error.captureStackTrace(this, y);
+          else {
+            var m = new Error();
+            if (m.stack) {
+              var O = m.stack, M = y.name, z = O.indexOf(`
+` + M);
+              if (z >= 0) {
+                var T = O.indexOf(`
+`, z + 1);
+                O = O.substring(T + 1);
+              }
+              this.stack = O;
+            }
+          }
+        }, C.inherits(d.AssertionError, Error);
+        function f(n, i) {
+          return C.isUndefined(i) ? "" + i : C.isNumber(i) && !isFinite(i) || C.isFunction(i) || C.isRegExp(i) ? i.toString() : i;
+        }
+        function h(n, i) {
+          return C.isString(n) ? n.length < i ? n : n.slice(0, i) : n;
+        }
+        function a(n) {
+          return h(JSON.stringify(n.actual, f), 128) + " " + n.operator + " " + h(JSON.stringify(n.expected, f), 128);
+        }
+        function o(n, i, y, m, O) {
+          throw new d.AssertionError({
+            message: y,
+            actual: n,
+            expected: i,
+            operator: m,
+            stackStartFunction: O
+          });
+        }
+        d.fail = o;
+        function A(n, i) {
+          n || o(n, !0, i, "==", d.ok);
+        }
+        d.ok = A, d.equal = function(i, y, m) {
+          i != y && o(i, y, m, "==", d.equal);
+        }, d.notEqual = function(i, y, m) {
+          i == y && o(i, y, m, "!=", d.notEqual);
+        }, d.deepEqual = function(i, y, m) {
+          s(i, y) || o(i, y, m, "deepEqual", d.deepEqual);
+        };
+        function s(n, i) {
+          if (n === i)
+            return !0;
+          if (C.isBuffer(n) && C.isBuffer(i)) {
+            if (n.length != i.length) return !1;
+            for (var y = 0; y < n.length; y++)
+              if (n[y] !== i[y]) return !1;
+            return !0;
+          } else return C.isDate(n) && C.isDate(i) ? n.getTime() === i.getTime() : C.isRegExp(n) && C.isRegExp(i) ? n.source === i.source && n.global === i.global && n.multiline === i.multiline && n.lastIndex === i.lastIndex && n.ignoreCase === i.ignoreCase : !C.isObject(n) && !C.isObject(i) ? n == i : r(n, i);
+        }
+        function p(n) {
+          return Object.prototype.toString.call(n) == "[object Arguments]";
+        }
+        function r(n, i) {
+          if (C.isNullOrUndefined(n) || C.isNullOrUndefined(i) || n.prototype !== i.prototype) return !1;
+          if (C.isPrimitive(n) || C.isPrimitive(i))
+            return n === i;
+          var y = p(n), m = p(i);
+          if (y && !m || !y && m)
+            return !1;
+          if (y)
+            return n = l.call(n), i = l.call(i), s(n, i);
+          var O = g(n), M = g(i), z, T;
+          if (O.length != M.length)
+            return !1;
+          for (O.sort(), M.sort(), T = O.length - 1; T >= 0; T--)
+            if (O[T] != M[T])
+              return !1;
+          for (T = O.length - 1; T >= 0; T--)
+            if (z = O[T], !s(n[z], i[z])) return !1;
+          return !0;
+        }
+        d.notDeepEqual = function(i, y, m) {
+          s(i, y) && o(i, y, m, "notDeepEqual", d.notDeepEqual);
+        }, d.strictEqual = function(i, y, m) {
+          i !== y && o(i, y, m, "===", d.strictEqual);
+        }, d.notStrictEqual = function(i, y, m) {
+          i === y && o(i, y, m, "!==", d.notStrictEqual);
+        };
+        function F(n, i) {
+          return !n || !i ? !1 : Object.prototype.toString.call(i) == "[object RegExp]" ? i.test(n) : n instanceof i ? !0 : i.call({}, n) === !0;
+        }
+        function w(n, i, y, m) {
+          var O;
+          C.isString(y) && (m = y, y = null);
+          try {
+            i();
+          } catch (M) {
+            O = M;
+          }
+          if (m = (y && y.name ? " (" + y.name + ")." : ".") + (m ? " " + m : "."), n && !O && o(O, y, "Missing expected exception" + m), !n && F(O, y) && o(O, y, "Got unwanted exception" + m), n && O && y && !F(O, y) || !n && O)
+            throw O;
+        }
+        d.throws = function(n, i, y) {
+          w.apply(this, [!0].concat(l.call(arguments)));
+        }, d.doesNotThrow = function(n, i) {
+          w.apply(this, [!1].concat(l.call(arguments)));
+        }, d.ifError = function(n) {
+          if (n)
+            throw n;
+        };
+        var g = Object.keys || function(n) {
+          var i = [];
+          for (var y in n)
+            S.call(n, y) && i.push(y);
+          return i;
+        };
+      }, { "util/": 11 }], 9: [function(x, k, D) {
+        typeof Object.create == "function" ? k.exports = function(l, S) {
+          l.super_ = S, l.prototype = Object.create(S.prototype, {
+            constructor: {
+              value: l,
+              enumerable: !1,
+              writable: !0,
+              configurable: !0
+            }
+          });
+        } : k.exports = function(l, S) {
+          l.super_ = S;
+          var d = function() {
+          };
+          d.prototype = S.prototype, l.prototype = new d(), l.prototype.constructor = l;
+        };
+      }, {}], 10: [function(x, k, D) {
+        k.exports = function(l) {
+          return l && typeof l == "object" && typeof l.copy == "function" && typeof l.fill == "function" && typeof l.readUInt8 == "function";
+        };
+      }, {}], 11: [function(x, k, D) {
+        (function(C, l) {
+          var S = /%[sdj%]/g;
+          D.format = function(v) {
+            if (!M(v)) {
+              for (var B = [], _ = 0; _ < arguments.length; _++)
+                B.push(h(arguments[_]));
+              return B.join(" ");
+            }
+            for (var _ = 1, K = arguments, re = K.length, H = String(v).replace(S, function(Q) {
+              if (Q === "%%") return "%";
+              if (_ >= re) return Q;
+              switch (Q) {
+                case "%s":
+                  return String(K[_++]);
+                case "%d":
+                  return Number(K[_++]);
+                case "%j":
+                  try {
+                    return JSON.stringify(K[_++]);
+                  } catch {
+                    return "[Circular]";
+                  }
+                default:
+                  return Q;
+              }
+            }), W = K[_]; _ < re; W = K[++_])
+              y(W) || !$(W) ? H += " " + W : H += " " + h(W);
+            return H;
+          }, D.deprecate = function(v, B) {
+            if (T(l.process))
+              return function() {
+                return D.deprecate(v, B).apply(this, arguments);
+              };
+            if (C.noDeprecation === !0)
+              return v;
+            var _ = !1;
+            function K() {
+              if (!_) {
+                if (C.throwDeprecation)
+                  throw new Error(B);
+                C.traceDeprecation ? console.trace(B) : console.error(B), _ = !0;
+              }
+              return v.apply(this, arguments);
+            }
+            return K;
+          };
+          var d = {}, f;
+          D.debuglog = function(v) {
+            if (T(f) && (f = C.env.NODE_DEBUG || ""), v = v.toUpperCase(), !d[v])
+              if (new RegExp("\\b" + v + "\\b", "i").test(f)) {
+                var B = C.pid;
+                d[v] = function() {
+                  var _ = D.format.apply(D, arguments);
+                  console.error("%s %d: %s", v, B, _);
+                };
+              } else
+                d[v] = function() {
+                };
+            return d[v];
+          };
+          function h(v, B) {
+            var _ = {
+              seen: [],
+              stylize: o
+            };
+            return arguments.length >= 3 && (_.depth = arguments[2]), arguments.length >= 4 && (_.colors = arguments[3]), i(B) ? _.showHidden = B : B && D._extend(_, B), T(_.showHidden) && (_.showHidden = !1), T(_.depth) && (_.depth = 2), T(_.colors) && (_.colors = !1), T(_.customInspect) && (_.customInspect = !0), _.colors && (_.stylize = a), s(_, v, _.depth);
+          }
+          D.inspect = h, h.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]
+          }, h.styles = {
+            special: "cyan",
+            number: "yellow",
+            boolean: "yellow",
+            undefined: "grey",
+            null: "bold",
+            string: "green",
+            date: "magenta",
+            // "name": intentionally not styling
+            regexp: "red"
+          };
+          function a(v, B) {
+            var _ = h.styles[B];
+            return _ ? "\x1B[" + h.colors[_][0] + "m" + v + "\x1B[" + h.colors[_][1] + "m" : v;
+          }
+          function o(v, B) {
+            return v;
+          }
+          function A(v) {
+            var B = {};
+            return v.forEach(function(_, K) {
+              B[_] = !0;
+            }), B;
+          }
+          function s(v, B, _) {
+            if (v.customInspect && B && ce(B.inspect) && // Filter out the util module, it's inspect function is special
+            B.inspect !== D.inspect && // Also filter out any prototype objects using the circular check.
+            !(B.constructor && B.constructor.prototype === B)) {
+              var K = B.inspect(_, v);
+              return M(K) || (K = s(v, K, _)), K;
+            }
+            var re = p(v, B);
+            if (re)
+              return re;
+            var H = Object.keys(B), W = A(H);
+            if (v.showHidden && (H = Object.getOwnPropertyNames(B)), J(B) && (H.indexOf("message") >= 0 || H.indexOf("description") >= 0))
+              return r(B);
+            if (H.length === 0) {
+              if (ce(B)) {
+                var Q = B.name ? ": " + B.name : "";
+                return v.stylize("[Function" + Q + "]", "special");
+              }
+              if (G(B))
+                return v.stylize(RegExp.prototype.toString.call(B), "regexp");
+              if (q(B))
+                return v.stylize(Date.prototype.toString.call(B), "date");
+              if (J(B))
+                return r(B);
+            }
+            var Z = "", me = !1, Se = ["{", "}"];
+            if (n(B) && (me = !0, Se = ["[", "]"]), ce(B)) {
+              var Le = B.name ? ": " + B.name : "";
+              Z = " [Function" + Le + "]";
+            }
+            if (G(B) && (Z = " " + RegExp.prototype.toString.call(B)), q(B) && (Z = " " + Date.prototype.toUTCString.call(B)), J(B) && (Z = " " + r(B)), H.length === 0 && (!me || B.length == 0))
+              return Se[0] + Z + Se[1];
+            if (_ < 0)
+              return G(B) ? v.stylize(RegExp.prototype.toString.call(B), "regexp") : v.stylize("[Object]", "special");
+            v.seen.push(B);
+            var De;
+            return me ? De = F(v, B, _, W, H) : De = H.map(function(_e) {
+              return w(v, B, _, W, _e, me);
+            }), v.seen.pop(), g(De, Z, Se);
+          }
+          function p(v, B) {
+            if (T(B))
+              return v.stylize("undefined", "undefined");
+            if (M(B)) {
+              var _ = "'" + JSON.stringify(B).replace(/^"|"$/g, "").replace(/'/g, "\\'").replace(/\\"/g, '"') + "'";
+              return v.stylize(_, "string");
+            }
+            if (O(B))
+              return v.stylize("" + B, "number");
+            if (i(B))
+              return v.stylize("" + B, "boolean");
+            if (y(B))
+              return v.stylize("null", "null");
+          }
+          function r(v) {
+            return "[" + Error.prototype.toString.call(v) + "]";
+          }
+          function F(v, B, _, K, re) {
+            for (var H = [], W = 0, Q = B.length; W < Q; ++W)
+              Ie(B, String(W)) ? H.push(w(
+                v,
+                B,
+                _,
+                K,
+                String(W),
+                !0
+              )) : H.push("");
+            return re.forEach(function(Z) {
+              Z.match(/^\d+$/) || H.push(w(
+                v,
+                B,
+                _,
+                K,
+                Z,
+                !0
+              ));
+            }), H;
+          }
+          function w(v, B, _, K, re, H) {
+            var W, Q, Z;
+            if (Z = Object.getOwnPropertyDescriptor(B, re) || { value: B[re] }, Z.get ? Z.set ? Q = v.stylize("[Getter/Setter]", "special") : Q = v.stylize("[Getter]", "special") : Z.set && (Q = v.stylize("[Setter]", "special")), Ie(K, re) || (W = "[" + re + "]"), Q || (v.seen.indexOf(Z.value) < 0 ? (y(_) ? Q = s(v, Z.value, null) : Q = s(v, Z.value, _ - 1), Q.indexOf(`
+`) > -1 && (H ? Q = Q.split(`
+`).map(function(me) {
+              return "  " + me;
+            }).join(`
+`).substr(2) : Q = `
+` + Q.split(`
+`).map(function(me) {
+              return "   " + me;
+            }).join(`
+`))) : Q = v.stylize("[Circular]", "special")), T(W)) {
+              if (H && re.match(/^\d+$/))
+                return Q;
+              W = JSON.stringify("" + re), W.match(/^"([a-zA-Z_][a-zA-Z_0-9]*)"$/) ? (W = W.substr(1, W.length - 2), W = v.stylize(W, "name")) : (W = W.replace(/'/g, "\\'").replace(/\\"/g, '"').replace(/(^"|"$)/g, "'"), W = v.stylize(W, "string"));
+            }
+            return W + ": " + Q;
+          }
+          function g(v, B, _) {
+            var K = v.reduce(function(re, H) {
+              return H.indexOf(`
+`) >= 0, re + H.replace(/\u001b\[\d\d?m/g, "").length + 1;
+            }, 0);
+            return K > 60 ? _[0] + (B === "" ? "" : B + `
+ `) + " " + v.join(`,
+  `) + " " + _[1] : _[0] + B + " " + v.join(", ") + " " + _[1];
+          }
+          function n(v) {
+            return Array.isArray(v);
+          }
+          D.isArray = n;
+          function i(v) {
+            return typeof v == "boolean";
+          }
+          D.isBoolean = i;
+          function y(v) {
+            return v === null;
+          }
+          D.isNull = y;
+          function m(v) {
+            return v == null;
+          }
+          D.isNullOrUndefined = m;
+          function O(v) {
+            return typeof v == "number";
+          }
+          D.isNumber = O;
+          function M(v) {
+            return typeof v == "string";
+          }
+          D.isString = M;
+          function z(v) {
+            return typeof v == "symbol";
+          }
+          D.isSymbol = z;
+          function T(v) {
+            return v === void 0;
+          }
+          D.isUndefined = T;
+          function G(v) {
+            return $(v) && Y(v) === "[object RegExp]";
+          }
+          D.isRegExp = G;
+          function $(v) {
+            return typeof v == "object" && v !== null;
+          }
+          D.isObject = $;
+          function q(v) {
+            return $(v) && Y(v) === "[object Date]";
+          }
+          D.isDate = q;
+          function J(v) {
+            return $(v) && (Y(v) === "[object Error]" || v instanceof Error);
+          }
+          D.isError = J;
+          function ce(v) {
+            return typeof v == "function";
+          }
+          D.isFunction = ce;
+          function ee(v) {
+            return v === null || typeof v == "boolean" || typeof v == "number" || typeof v == "string" || typeof v == "symbol" || // ES6 symbol
+            typeof v > "u";
+          }
+          D.isPrimitive = ee, D.isBuffer = x("./support/isBuffer");
+          function Y(v) {
+            return Object.prototype.toString.call(v);
+          }
+          function fe(v) {
+            return v < 10 ? "0" + v.toString(10) : v.toString(10);
+          }
+          var oe = [
+            "Jan",
+            "Feb",
+            "Mar",
+            "Apr",
+            "May",
+            "Jun",
+            "Jul",
+            "Aug",
+            "Sep",
+            "Oct",
+            "Nov",
+            "Dec"
+          ];
+          function pe() {
+            var v = /* @__PURE__ */ new Date(), B = [
+              fe(v.getHours()),
+              fe(v.getMinutes()),
+              fe(v.getSeconds())
+            ].join(":");
+            return [v.getDate(), oe[v.getMonth()], B].join(" ");
+          }
+          D.log = function() {
+            console.log("%s - %s", pe(), D.format.apply(D, arguments));
+          }, D.inherits = x("inherits"), D._extend = function(v, B) {
+            if (!B || !$(B)) return v;
+            for (var _ = Object.keys(B), K = _.length; K--; )
+              v[_[K]] = B[_[K]];
+            return v;
+          };
+          function Ie(v, B) {
+            return Object.prototype.hasOwnProperty.call(v, B);
+          }
+        }).call(this, x("_process"), typeof at < "u" ? at : typeof self < "u" ? self : typeof window < "u" ? window : {});
+      }, { "./support/isBuffer": 10, _process: 14, inherits: 9 }], 12: [function(x, k, D) {
+      }, {}], 13: [function(x, k, D) {
+        (function(C) {
+          function l(h, a) {
+            for (var o = 0, A = h.length - 1; A >= 0; A--) {
+              var s = h[A];
+              s === "." ? h.splice(A, 1) : s === ".." ? (h.splice(A, 1), o++) : o && (h.splice(A, 1), o--);
+            }
+            if (a)
+              for (; o--; o)
+                h.unshift("..");
+            return h;
+          }
+          D.resolve = function() {
+            for (var h = "", a = !1, o = arguments.length - 1; o >= -1 && !a; o--) {
+              var A = o >= 0 ? arguments[o] : C.cwd();
+              if (typeof A != "string")
+                throw new TypeError("Arguments to path.resolve must be strings");
+              if (!A)
+                continue;
+              h = A + "/" + h, a = A.charAt(0) === "/";
+            }
+            return h = l(d(h.split("/"), function(s) {
+              return !!s;
+            }), !a).join("/"), (a ? "/" : "") + h || ".";
+          }, D.normalize = function(h) {
+            var a = D.isAbsolute(h), o = f(h, -1) === "/";
+            return h = l(d(h.split("/"), function(A) {
+              return !!A;
+            }), !a).join("/"), !h && !a && (h = "."), h && o && (h += "/"), (a ? "/" : "") + h;
+          }, D.isAbsolute = function(h) {
+            return h.charAt(0) === "/";
+          }, D.join = function() {
+            var h = Array.prototype.slice.call(arguments, 0);
+            return D.normalize(d(h, function(a, o) {
+              if (typeof a != "string")
+                throw new TypeError("Arguments to path.join must be strings");
+              return a;
+            }).join("/"));
+          }, D.relative = function(h, a) {
+            h = D.resolve(h).substr(1), a = D.resolve(a).substr(1);
+            function o(g) {
+              for (var n = 0; n < g.length && g[n] === ""; n++)
+                ;
+              for (var i = g.length - 1; i >= 0 && g[i] === ""; i--)
+                ;
+              return n > i ? [] : g.slice(n, i - n + 1);
+            }
+            for (var A = o(h.split("/")), s = o(a.split("/")), p = Math.min(A.length, s.length), r = p, F = 0; F < p; F++)
+              if (A[F] !== s[F]) {
+                r = F;
+                break;
+              }
+            for (var w = [], F = r; F < A.length; F++)
+              w.push("..");
+            return w = w.concat(s.slice(r)), w.join("/");
+          }, D.sep = "/", D.delimiter = ":", D.dirname = function(h) {
+            if (typeof h != "string" && (h = h + ""), h.length === 0) return ".";
+            for (var a = h.charCodeAt(0), o = a === 47, A = -1, s = !0, p = h.length - 1; p >= 1; --p)
+              if (a = h.charCodeAt(p), a === 47) {
+                if (!s) {
+                  A = p;
+                  break;
+                }
+              } else
+                s = !1;
+            return A === -1 ? o ? "/" : "." : o && A === 1 ? "/" : h.slice(0, A);
+          };
+          function S(h) {
+            typeof h != "string" && (h = h + "");
+            var a = 0, o = -1, A = !0, s;
+            for (s = h.length - 1; s >= 0; --s)
+              if (h.charCodeAt(s) === 47) {
+                if (!A) {
+                  a = s + 1;
+                  break;
+                }
+              } else o === -1 && (A = !1, o = s + 1);
+            return o === -1 ? "" : h.slice(a, o);
+          }
+          D.basename = function(h, a) {
+            var o = S(h);
+            return a && o.substr(-1 * a.length) === a && (o = o.substr(0, o.length - a.length)), o;
+          }, D.extname = function(h) {
+            typeof h != "string" && (h = h + "");
+            for (var a = -1, o = 0, A = -1, s = !0, p = 0, r = h.length - 1; r >= 0; --r) {
+              var F = h.charCodeAt(r);
+              if (F === 47) {
+                if (!s) {
+                  o = r + 1;
+                  break;
+                }
+                continue;
+              }
+              A === -1 && (s = !1, A = r + 1), F === 46 ? a === -1 ? a = r : p !== 1 && (p = 1) : a !== -1 && (p = -1);
+            }
+            return a === -1 || A === -1 || // We saw a non-dot character immediately before the dot
+            p === 0 || // The (right-most) trimmed path component is exactly '..'
+            p === 1 && a === A - 1 && a === o + 1 ? "" : h.slice(a, A);
+          };
+          function d(h, a) {
+            if (h.filter) return h.filter(a);
+            for (var o = [], A = 0; A < h.length; A++)
+              a(h[A], A, h) && o.push(h[A]);
+            return o;
+          }
+          var f = "ab".substr(-1) === "b" ? function(h, a, o) {
+            return h.substr(a, o);
+          } : function(h, a, o) {
+            return a < 0 && (a = h.length + a), h.substr(a, o);
+          };
+        }).call(this, x("_process"));
+      }, { _process: 14 }], 14: [function(x, k, D) {
+        var C = k.exports = {}, l, S;
+        function d() {
+          throw new Error("setTimeout has not been defined");
+        }
+        function f() {
+          throw new Error("clearTimeout has not been defined");
+        }
+        (function() {
+          try {
+            typeof setTimeout == "function" ? l = setTimeout : l = d;
+          } catch {
+            l = d;
+          }
+          try {
+            typeof clearTimeout == "function" ? S = clearTimeout : S = f;
+          } catch {
+            S = f;
+          }
+        })();
+        function h(n) {
+          if (l === setTimeout)
+            return setTimeout(n, 0);
+          if ((l === d || !l) && setTimeout)
+            return l = setTimeout, setTimeout(n, 0);
+          try {
+            return l(n, 0);
+          } catch {
+            try {
+              return l.call(null, n, 0);
+            } catch {
+              return l.call(this, n, 0);
+            }
+          }
+        }
+        function a(n) {
+          if (S === clearTimeout)
+            return clearTimeout(n);
+          if ((S === f || !S) && clearTimeout)
+            return S = clearTimeout, clearTimeout(n);
+          try {
+            return S(n);
+          } catch {
+            try {
+              return S.call(null, n);
+            } catch {
+              return S.call(this, n);
+            }
+          }
+        }
+        var o = [], A = !1, s, p = -1;
+        function r() {
+          !A || !s || (A = !1, s.length ? o = s.concat(o) : p = -1, o.length && F());
+        }
+        function F() {
+          if (!A) {
+            var n = h(r);
+            A = !0;
+            for (var i = o.length; i; ) {
+              for (s = o, o = []; ++p < i; )
+                s && s[p].run();
+              p = -1, i = o.length;
+            }
+            s = null, A = !1, a(n);
+          }
+        }
+        C.nextTick = function(n) {
+          var i = new Array(arguments.length - 1);
+          if (arguments.length > 1)
+            for (var y = 1; y < arguments.length; y++)
+              i[y - 1] = arguments[y];
+          o.push(new w(n, i)), o.length === 1 && !A && h(F);
+        };
+        function w(n, i) {
+          this.fun = n, this.array = i;
+        }
+        w.prototype.run = function() {
+          this.fun.apply(null, this.array);
+        }, C.title = "browser", C.browser = !0, C.env = {}, C.argv = [], C.version = "", C.versions = {};
+        function g() {
+        }
+        C.on = g, C.addListener = g, C.once = g, C.off = g, C.removeListener = g, C.removeAllListeners = g, C.emit = g, C.prependListener = g, C.prependOnceListener = g, C.listeners = function(n) {
+          return [];
+        }, C.binding = function(n) {
+          throw new Error("process.binding is not supported");
+        }, C.cwd = function() {
+          return "/";
+        }, C.chdir = function(n) {
+          throw new Error("process.chdir is not supported");
+        }, C.umask = function() {
+          return 0;
+        };
+      }, {}], 15: [function(x, k, D) {
+        var C = x("escodegen").generate;
+        k.exports = function(l, S) {
+          S || (S = {});
+          var d = {}, f = function h(a, o) {
+            if (a.type === "Literal")
+              return a.value;
+            if (a.type === "UnaryExpression") {
+              var A = h(a.argument);
+              return a.operator === "+" ? +A : a.operator === "-" ? -A : a.operator === "~" ? ~A : a.operator === "!" ? !A : d;
+            } else if (a.type === "ArrayExpression") {
+              for (var s = [], p = 0, r = a.elements.length; p < r; p++) {
+                var F = h(a.elements[p]);
+                if (F === d) return d;
+                s.push(F);
+              }
+              return s;
+            } else if (a.type === "ObjectExpression") {
+              for (var w = {}, p = 0; p < a.properties.length; p++) {
+                var g = a.properties[p], n = g.value === null ? g.value : h(g.value);
+                if (n === d) return d;
+                w[g.key.value || g.key.name] = n;
+              }
+              return w;
+            } else if (a.type === "BinaryExpression" || a.type === "LogicalExpression") {
+              var r = h(a.left);
+              if (r === d) return d;
+              var i = h(a.right);
+              if (i === d) return d;
+              var y = a.operator;
+              return y === "==" ? r == i : y === "===" ? r === i : y === "!=" ? r != i : y === "!==" ? r !== i : y === "+" ? r + i : y === "-" ? r - i : y === "*" ? r * i : y === "/" ? r / i : y === "%" ? r % i : y === "<" ? r < i : y === "<=" ? r <= i : y === ">" ? r > i : y === ">=" ? r >= i : y === "|" ? r | i : y === "&" ? r & i : y === "^" ? r ^ i : y === "&&" ? r && i : y === "||" ? r || i : d;
+            } else {
+              if (a.type === "Identifier")
+                return {}.hasOwnProperty.call(S, a.name) ? S[a.name] : d;
+              if (a.type === "ThisExpression")
+                return {}.hasOwnProperty.call(S, "this") ? S.this : d;
+              if (a.type === "CallExpression") {
+                var m = h(a.callee);
+                if (m === d || typeof m != "function") return d;
+                var O = a.callee.object ? h(a.callee.object) : d;
+                O === d && (O = null);
+                for (var M = [], p = 0, r = a.arguments.length; p < r; p++) {
+                  var F = h(a.arguments[p]);
+                  if (F === d) return d;
+                  M.push(F);
+                }
+                return m.apply(O, M);
+              } else if (a.type === "MemberExpression") {
+                var w = h(a.object);
+                if (w === d || typeof w == "function")
+                  return d;
+                if (a.property.type === "Identifier")
+                  return w[a.property.name];
+                var g = h(a.property);
+                return g === d ? d : w[g];
+              } else if (a.type === "ConditionalExpression") {
+                var A = h(a.test);
+                return A === d ? d : h(A ? a.consequent : a.alternate);
+              } else if (a.type === "ExpressionStatement") {
+                var A = h(a.expression);
+                return A === d ? d : A;
+              } else {
+                if (a.type === "ReturnStatement")
+                  return h(a.argument);
+                if (a.type === "FunctionExpression") {
+                  var z = a.body.body, T = {};
+                  Object.keys(S).forEach(function(oe) {
+                    T[oe] = S[oe];
+                  });
+                  for (var p = 0; p < a.params.length; p++) {
+                    var G = a.params[p];
+                    if (G.type == "Identifier")
+                      S[G.name] = null;
+                    else return d;
+                  }
+                  for (var p in z)
+                    if (h(z[p]) === d)
+                      return d;
+                  S = T;
+                  var $ = Object.keys(S), q = $.map(function(oe) {
+                    return S[oe];
+                  });
+                  return Function($.join(", "), "return " + C(a)).apply(null, q);
+                } else if (a.type === "TemplateLiteral") {
+                  for (var J = "", p = 0; p < a.expressions.length; p++)
+                    J += h(a.quasis[p]), J += h(a.expressions[p]);
+                  return J += h(a.quasis[p]), J;
+                } else if (a.type === "TaggedTemplateExpression") {
+                  var ce = h(a.tag), ee = a.quasi, Y = ee.quasis.map(h), fe = ee.expressions.map(h);
+                  return ce.apply(null, [Y].concat(fe));
+                } else return a.type === "TemplateElement" ? a.value.cooked : d;
+              }
+            }
+          }(l);
+          return f === d ? void 0 : f;
+        };
+      }, { escodegen: 12 }], jsonpath: [function(x, k, D) {
+        k.exports = x("./lib/index");
+      }, { "./lib/index": 5 }] }, {}, ["jsonpath"])("jsonpath");
+    });
+  }(He)), He.exports;
+}
+var rr = tr();
+const nr = /* @__PURE__ */ er(rr), lt = (E) => E && E.charAt(0).toUpperCase() + E.slice(1), Re = (E, P, x) => {
+  const { globalDataContext: k, templateContext: D } = P;
+  if (Array.isArray(E.andConditions))
+    return E.andConditions.reduce((d, f) => d && Re(f, P, x), !0);
+  if (Array.isArray(E.orConditions)) {
+    const d = E.orConditions;
+    for (const f of d)
+      if (Re(f, P, x))
+        return !0;
+    return !1;
+  }
+  if (E.when !== void 0 && !ht(E.when))
+    return !1;
+  const C = (d) => ke({
+    globalDataContext: k,
+    templateContext: D,
+    valueToEvaluate: d
+  });
+  let l;
+  if (E.when === void 0 && E.hasOwnProperty("whenDataCountOf")) {
+    let d;
+    switch (E.inContext) {
+      case "root":
+        d = k.getRootContext().templateData;
+        break;
+      case "template":
+        d = D.templateData;
+        break;
+      default:
+        d = k.templateData;
+        break;
+    }
+    l = nr.query(d, E.whenDataCountOf).length;
+  } else
+    l = (() => {
+      if (x) {
+        for (const [d, f] of x)
+          if (E.hasOwnProperty(d))
+            return f({
+              condition: E,
+              templateContexts: P,
+              evaluateAgainstTemplates: (h) => C(h)
+            });
+      }
+      return C(E.when);
+    })();
+  if (E.hasOwnProperty("isEmpty") || E.hasOwnProperty("isNotEmpty")) {
+    const d = (f) => E.hasOwnProperty("isEmpty") ? E.isEmpty === "not" ? !f : f : !f;
+    if (l === null)
+      return d(!0);
+    switch (typeof l) {
+      case "undefined":
+        return d(!0);
+      case "string":
+        return d(l.length === 0);
+      case "object":
+        return d(Object.keys(l).length === 0);
+      default:
+        return d(!l);
+    }
+  }
+  const S = E.compareAsDates;
+  if (E.hasOwnProperty("isNot"))
+    return se(S, l) !== se(S, C(E.isNot));
+  if (E.hasOwnProperty("is"))
+    return se(S, l) === se(S, C(E.is));
+  if (E.hasOwnProperty("containsNot") || E.hasOwnProperty("contains")) {
+    const d = E.hasOwnProperty("containsNot"), f = d ? E.containsNot : E.contains, h = se(S, C(f));
+    if (typeof l == "string") {
+      if (typeof h != "string")
+        return d;
+      const a = l.toLowerCase().indexOf(h.toLowerCase()) !== -1;
+      return d ? !a : a;
+    } else
+      for (const a of Object.values(l))
+        if (st.isEqual(se(S, a), h))
+          return !d;
+    return d;
+  }
+  if (E.hasOwnProperty("containedByNot") || E.hasOwnProperty("containedBy")) {
+    const d = E.hasOwnProperty("containedByNot"), f = d ? E.containedByNot : E.containedBy, h = se(S, C(f));
+    if (typeof l == "string") {
+      if (typeof h != "string")
+        return d;
+      const a = h.toLowerCase().indexOf(l.toLowerCase()) !== -1;
+      return d ? !a : a;
+    } else
+      for (const a of Object.values(h))
+        if (st.isEqual(se(S, a), l))
+          return !d;
+    return d;
+  }
+  return E.hasOwnProperty(">") ? se(S, l) > se(S, C(E[">"])) : E.hasOwnProperty(">=") ? se(S, l) >= se(S, C(E[">="])) : E.hasOwnProperty("<") ? se(S, l) < se(S, C(E["<"])) : E.hasOwnProperty("<=") ? se(S, l) <= se(S, C(E["<="])) : !0;
+}, ur = (E, P) => {
+  const x = [];
+  let k = !1;
+  const D = {};
+  if (!Array.isArray(E))
+    return x;
+  const { globalDataContext: C } = P, l = C.plugins ?? {}, S = (l == null ? void 0 : l.action) ?? {}, d = (l == null ? void 0 : l.reaction) ?? {};
+  if (!S)
+    return x;
+  for (const [f, h] of E.entries()) {
+    const a = (h == null ? void 0 : h.what) ?? void 0;
+    if (!a)
+      continue;
+    let o = S[a] ?? void 0, A = d[a] ?? void 0;
+    if (!o && !A && (o = S[lt(a)]), !o) {
+      if (!A || h.on === void 0 || !Re(h, P))
+        continue;
+      if (h.on === "message") {
+        if (!S.MessageListener)
+          continue;
+        x.push({ ActionComponent: S.MessageListener, actionProps: h, actionIndex: f });
+        continue;
+      }
+      if (h.on === "hashchange") {
+        if (!S.HashChangeListener)
+          continue;
+        x.push({ ActionComponent: S.HashChangeListener, actionProps: h, actionIndex: f });
+        continue;
+      }
+      k = !0;
+      const s = "on" + lt(h.on);
+      Array.isArray(D[s]) || (D[s] = []), D[s].push(h);
+      continue;
+    }
+    Re(h, P) && x.push({ ActionComponent: o, actionProps: h, actionIndex: f });
+  }
+  if (k) {
+    if (!S.ReactOnEvent)
+      return x;
+    x.push({
+      ActionComponent: S.ReactOnEvent,
+      actionProps: D,
+      actionIndex: "_reactOnEvent"
+    });
+  }
+  return x;
+}, se = (E, P) => E ? new Date(P) : P, ir = (E) => {
+  const P = Ee(we), x = Ee(be);
+  return E ? ur((E == null ? void 0 : E.actions) ?? [], { globalDataContext: P, templateContext: x }).reverse().reduce((D, { ActionComponent: C, actionProps: l, actionIndex: S }) => /* @__PURE__ */ le(
+    C,
+    {
+      componentProps: E,
+      actionProps: l,
+      actionIndex: S,
+      attributesHolderRef: E.attributesHolderRef,
+      children: D
+    }
+  ), (E == null ? void 0 : E.children) ?? null) : null;
+}, qe = (E) => {
+  if (typeof E != "object" || Object.keys(E).length === 0)
+    return {};
+  const P = {
+    class: "className"
+    // TODO: checked to defaultChecked seems incorrect. Commented out for removal.
+    // "checked": "defaultChecked",
+  }, x = {};
+  for (const [k, D] of Object.entries(E)) {
+    const C = P.hasOwnProperty(k) ? P[k] : k;
+    x[C] = D;
+  }
+  return x;
+}, ct = ({ props: E, currentData: P, datafield: x, path: k }) => {
+  const D = Ee(we), C = Ee(be), l = Zt(null), S = `${E.tag}`, d = E.extra ?? {}, f = qe(E.attributes), h = qe(P.attributes);
+  for (const A of Object.keys(h)) {
+    if (A.charAt(0) === "+") {
+      const s = A.substring(1);
+      f[s] = (f[s] ?? "").length > 0 ? (
+        // Append using a space.
+        " " + h[A]
+      ) : (
+        // Set directly.
+        h[A]
+      );
+      continue;
+    }
+    f[A] = h[A];
+  }
+  const a = pt({ attrs: f, globalDataContext: D, templateContext: C });
+  return /* @__PURE__ */ le(ir, { ...E, attributesHolderRef: l, children: ((A) => A && [
+    "area",
+    "base",
+    "br",
+    "col",
+    "embed",
+    "hr",
+    "img",
+    "input",
+    "link",
+    "meta",
+    "param",
+    "source",
+    "track",
+    "wbr"
+  ].indexOf(A) !== -1)(E.tag) ? /* @__PURE__ */ ut(it, { children: [
+    /* @__PURE__ */ le(S, { ref: l, ...a }),
+    Object.keys(d).length ? /* @__PURE__ */ le(ve, { props: d }) : ""
+  ] }) : /* @__PURE__ */ ut(it, { children: [
+    /* @__PURE__ */ le(S, { ref: l, ...a, children: E.content && /* @__PURE__ */ le(
+      ve,
+      {
+        currentData: P.content ?? void 0,
+        datafield: "content",
+        path: k + ".content",
+        props: E.content
+      }
+    ) }),
+    Object.keys(d).length ? /* @__PURE__ */ le(ve, { props: d }) : ""
+  ] }) });
+}, ft = ({ dataLocation: E, currentPath: P, globalDataContext: x, templateContext: k }) => {
+  if (typeof E != "string" || !(E.startsWith("~.") || E.startsWith("~~.") || E.startsWith("~>") || E.startsWith("~~>")))
+    return E === "~" ? k.templatePath : E === "~~" ? x.templatePath : E;
+  let D;
+  if (E.startsWith("~~."))
+    D = x.templatePath;
+  else if (E.startsWith("~."))
+    D = k.templatePath;
+  else if (E.startsWith("~>") || E.startsWith("~~>")) {
+    const l = E.startsWith("~>") ? "~>" : "~~>", S = E.indexOf("."), d = S === -1 ? E.substring(l.length) : E.substring(l.length, S);
+    if (!k.templatePath.includes(d))
+      throw new Error(
+        d + " not found in the current template path. The current template path is: " + k.templatePath
+      );
+    let f;
+    l === "~>" ? f = k.templatePath.lastIndexOf(d) : f = k.templatePath.indexOf(d), D = k.templatePath.substring(0, f + d.length);
+  } else
+    D = P;
+  const C = E.split(".");
+  return C.shift(), C.length ? D + "." + C.join(".") : D;
+}, pt = ({ attrs: E, globalDataContext: P, templateContext: x, options: k = {} }) => {
+  const D = {};
+  if (!E)
+    return D;
+  const C = k.normalizeBeforeEvaluation ? qe(E) : E;
+  for (const l of Object.keys(C)) {
+    const S = Ge({
+      globalDataContext: P,
+      templateContext: x,
+      valueToEvaluate: C[l]
+    });
+    S && (D[l] = S);
+  }
+  return D;
+}, ke = ({ valueToEvaluate: E, globalDataContext: P, templateContext: x }) => {
+  if (!ht(E))
+    return E;
+  if (E === "~")
+    return x.templateData;
+  if (E === "~~")
+    return P.templateData;
+  let k;
+  if (E.startsWith("~~.") ? k = P == null ? void 0 : P.templateData : E.startsWith("~>") || E.startsWith("~~>") ? (E = ft({
+    dataLocation: E,
+    currentPath: x.templatePath,
+    globalDataContext: P,
+    templateContext: x
+  }), k = P == null ? void 0 : P.templateData) : k = x == null ? void 0 : x.templateData, !k)
+    return;
+  const D = E.split(".");
+  for (D.shift(); D.length; )
+    if (typeof k != "object" || (k = k[D.shift()], k === void 0))
+      return;
+  return k;
+}, Ge = ({
+  valueToEvaluate: E,
+  globalDataContext: P,
+  templateContext: x,
+  evaluationDepth: k = 1
+}) => {
+  if (k === 0 || k <= -20)
+    return E;
+  let C;
+  if (typeof E == "object") {
+    C = Array.isArray(E) ? [] : {};
+    for (const [l, S] of Object.entries(E)) {
+      const d = ke({
+        globalDataContext: P,
+        templateContext: x,
+        valueToEvaluate: S
+      });
+      (k > 1 || k < 0) && typeof d == "object" && d !== null ? C[l] = Ge({
+        valueToEvaluate: d,
+        globalDataContext: P,
+        templateContext: x,
+        evaluationDepth: k - 1
+      }) : C[l] = d;
+    }
+  } else
+    C = ke({
+      globalDataContext: P,
+      templateContext: x,
+      valueToEvaluate: E
+    }), (k > 1 || k < 0) && typeof C == "object" && C !== null && (C = Ge({
+      valueToEvaluate: C,
+      globalDataContext: P,
+      templateContext: x,
+      evaluationDepth: k - 1
+    }));
+  return C;
+}, ht = (E) => typeof E != "string" || !(E.startsWith("~.") || E.startsWith("~~.") || E.startsWith("~>") || E.startsWith("~~>") || E === "~" || E === "~~") ? !1 : E, ar = ({ valueToEvaluate: E }) => {
+  const P = Ee(we), x = Ee(be);
+  return ke({
+    globalDataContext: P,
+    templateContext: x,
+    valueToEvaluate: E
+  });
+}, hr = (E, P = {}) => {
+  const x = Ee(we), k = Ee(be);
+  return pt({
+    attrs: E,
+    globalDataContext: x,
+    templateContext: k,
+    options: P.normalizeBeforeEvaluation === void 0 ? { ...P, normalizeBeforeEvaluation: !0 } : P
+  });
+};
+export {
+  ir as A,
+  ct as H,
+  nr as J,
+  ar as T,
+  ve as V,
+  ke as a,
+  Ge as b,
+  ht as c,
+  ft as d,
+  pt as e,
+  Re as i,
+  qe as n,
+  hr as u
+};