import { h$ as commonjsGlobal, bS as getDefaultExportFromCjs, d as defineComponent, hf as nonExistingJsonPath, b$ as inject, r as ref, cb as PopOutWindowKey, x as computed, aY as useNDVStore, a1 as useWorkflowsStore, ca as useClipboard, bL as useNodeHelpers, bJ as usePinnedData, a as useToast, a2 as useRoute, h as createElementBlock, g as openBlock, e as createBlock, l as unref, c as useI18n, aa as _sfc_main$1, w as withCtx, j as createBaseVNode, i as createVNode, H as ElDropdownMenu, I as ElDropdownItem, k as createTextVNode, t as toDisplayString, E as ElDropdown, n as normalizeClass, al as useTelemetry, i0 as clearJsonKey, hc as executionDataToJson, i1 as convertPath, _ as _export_sfc } from "./index--OJ5nhDf.js";
import { c as commonjsRequire } from "./_commonjs-dynamic-modules-TGKdzP3c.js";
var jsonpath = { exports: {} };
/*! jsonpath 1.1.1 */
var hasRequiredJsonpath;
function requireJsonpath() {
  if (hasRequiredJsonpath) return jsonpath.exports;
  hasRequiredJsonpath = 1;
  (function(module, exports) {
    (function(f) {
      {
        module.exports = f();
      }
    })(function() {
      return (function e(t, n, r) {
        function s(o2, u) {
          if (!n[o2]) {
            if (!t[o2]) {
              var a = typeof commonjsRequire == "function" && commonjsRequire;
              if (!u && a) return a(o2, true);
              if (i) return i(o2, true);
              var f = new Error("Cannot find module '" + o2 + "'");
              throw f.code = "MODULE_NOT_FOUND", f;
            }
            var l = n[o2] = { exports: {} };
            t[o2][0].call(l.exports, function(e2) {
              var n2 = t[o2][1][e2];
              return s(n2 ? n2 : e2);
            }, l, l.exports, e, t, n, r);
          }
          return n[o2].exports;
        }
        var i = typeof commonjsRequire == "function" && commonjsRequire;
        for (var o = 0; o < r.length; o++) s(r[o]);
        return s;
      })({ "./aesprim": [function(require2, module3, exports3) {
        (function(root, factory) {
          if (typeof exports3 !== "undefined") {
            factory(exports3);
          } else {
            factory(root.esprima = {});
          }
        })(this, function(exports4) {
          var Token, TokenName, FnExprTokens, Syntax, PropertyKind, Messages, Regex, SyntaxTreeDelegate, source, strict, index, lineNumber, lineStart, length, delegate, lookahead, state, extra;
          Token = {
            BooleanLiteral: 1,
            EOF: 2,
            Identifier: 3,
            Keyword: 4,
            NullLiteral: 5,
            NumericLiteral: 6,
            Punctuator: 7,
            StringLiteral: 8,
            RegularExpression: 9
          };
          TokenName = {};
          TokenName[Token.BooleanLiteral] = "Boolean";
          TokenName[Token.EOF] = "<end>";
          TokenName[Token.Identifier] = "Identifier";
          TokenName[Token.Keyword] = "Keyword";
          TokenName[Token.NullLiteral] = "Null";
          TokenName[Token.NumericLiteral] = "Numeric";
          TokenName[Token.Punctuator] = "Punctuator";
          TokenName[Token.StringLiteral] = "String";
          TokenName[Token.RegularExpression] = "RegularExpression";
          FnExprTokens = [
            "(",
            "{",
            "[",
            "in",
            "typeof",
            "instanceof",
            "new",
            "return",
            "case",
            "delete",
            "throw",
            "void",
            // assignment operators
            "=",
            "+=",
            "-=",
            "*=",
            "/=",
            "%=",
            "<<=",
            ">>=",
            ">>>=",
            "&=",
            "|=",
            "^=",
            ",",
            // binary/unary operators
            "+",
            "-",
            "*",
            "/",
            "%",
            "++",
            "--",
            "<<",
            ">>",
            ">>>",
            "&",
            "|",
            "^",
            "!",
            "~",
            "&&",
            "||",
            "?",
            ":",
            "===",
            "==",
            ">=",
            "<=",
            "<",
            ">",
            "!=",
            "!=="
          ];
          Syntax = {
            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"
          };
          PropertyKind = {
            Data: 1,
            Get: 2,
            Set: 4
          };
          Messages = {
            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"
          };
          Regex = {
            NonAsciiIdentifierStart: new RegExp("[ªµºÀ-ÖØ-öø-ˁˆ-ˑˠ-ˤˬˮͰ-ʹͶͷͺ-ͽΆΈ-ΊΌΎ-ΡΣ-ϵϷ-ҁҊ-ԧԱ-Ֆՙա-ևא-תװ-ײؠ-يٮٯٱ-ۓەۥۦۮۯۺ-ۼۿܐܒ-ܯݍ-ޥޱߊ-ߪߴߵߺࠀ-ࠕࠚࠤࠨࡀ-ࡘࢠࢢ-ࢬऄ-हऽॐक़-ॡॱ-ॷॹ-ॿঅ-ঌএঐও-নপ-রলশ-হঽৎড়ঢ়য়-ৡৰৱਅ-ਊਏਐਓ-ਨਪ-ਰਲਲ਼ਵਸ਼ਸਹਖ਼-ੜਫ਼ੲ-ੴઅ-ઍએ-ઑઓ-નપ-રલળવ-હઽૐૠૡଅ-ଌଏଐଓ-ନପ-ରଲଳଵ-ହଽଡ଼ଢ଼ୟ-ୡୱஃஅ-ஊஎ-ஐஒ-கஙசஜஞடணதந-பம-ஹௐఅ-ఌఎ-ఐఒ-నప-ళవ-హఽౘౙౠౡಅ-ಌಎ-ಐಒ-ನಪ-ಳವ-ಹಽೞೠೡೱೲഅ-ഌഎ-ഐഒ-ഺഽൎൠൡൺ-ൿඅ-ඖක-නඳ-රලව-ෆก-ะาำเ-ๆກຂຄງຈຊຍດ-ທນ-ຟມ-ຣລວສຫອ-ະາຳຽເ-ໄໆໜ-ໟༀཀ-ཇཉ-ཬྈ-ྌက-ဪဿၐ-ၕၚ-ၝၡၥၦၮ-ၰၵ-ႁႎႠ-ჅჇჍა-ჺჼ-ቈቊ-ቍቐ-ቖቘቚ-ቝበ-ኈኊ-ኍነ-ኰኲ-ኵኸ-ኾዀዂ-ዅወ-ዖዘ-ጐጒ-ጕጘ-ፚᎀ-ᎏᎠ-Ᏼᐁ-ᙬᙯ-ᙿᚁ-ᚚᚠ-ᛪᛮ-ᛰᜀ-ᜌᜎ-ᜑᜠ-ᜱᝀ-ᝑᝠ-ᝬᝮ-ᝰក-ឳៗៜᠠ-ᡷᢀ-ᢨᢪᢰ-ᣵᤀ-ᤜᥐ-ᥭᥰ-ᥴᦀ-ᦫᧁ-ᧇᨀ-ᨖᨠ-ᩔᪧᬅ-ᬳᭅ-ᭋᮃ-ᮠᮮᮯᮺ-ᯥᰀ-ᰣᱍ-ᱏᱚ-ᱽᳩ-ᳬᳮ-ᳱᳵᳶᴀ-ᶿḀ-ἕἘ-Ἕἠ-ὅὈ-Ὅὐ-ὗὙὛὝὟ-ώᾀ-ᾴᾶ-ᾼιῂ-ῄῆ-ῌῐ-ΐῖ-Ίῠ-Ῥῲ-ῴῶ-ῼⁱⁿₐ-ₜℂℇℊ-ℓℕℙ-ℝℤΩℨK-ℭℯ-ℹℼ-ℿⅅ-ⅉⅎⅠ-ↈⰀ-Ⱞⰰ-ⱞⱠ-ⳤⳫ-ⳮⳲⳳⴀ-ⴥⴧⴭⴰ-ⵧⵯⶀ-ⶖⶠ-ⶦⶨ-ⶮⶰ-ⶶⶸ-ⶾⷀ-ⷆⷈ-ⷎⷐ-ⷖⷘ-ⷞⸯ々-〇〡-〩〱-〵〸-〼ぁ-ゖゝ-ゟァ-ヺー-ヿㄅ-ㄭㄱ-ㆎㆠ-ㆺㇰ-ㇿ㐀-䶵一-鿌ꀀ-ꒌꓐ-ꓽꔀ-ꘌꘐ-ꘟꘪꘫꙀ-ꙮꙿ-ꚗꚠ-ꛯꜗ-ꜟꜢ-ꞈꞋ-ꞎꞐ-ꞓꞠ-Ɦꟸ-ꠁꠃ-ꠅꠇ-ꠊꠌ-ꠢꡀ-ꡳꢂ-ꢳꣲ-ꣷꣻꤊ-ꤥꤰ-ꥆꥠ-ꥼꦄ-ꦲꧏꨀ-ꨨꩀ-ꩂꩄ-ꩋꩠ-ꩶꩺꪀ-ꪯꪱꪵꪶꪹ-ꪽꫀꫂꫛ-ꫝꫠ-ꫪꫲ-ꫴꬁ-ꬆꬉ-ꬎꬑ-ꬖꬠ-ꬦꬨ-ꬮꯀ-ꯢ가-힣ힰ-ퟆퟋ-ퟻ豈-舘並-龎ff-stﬓ-ﬗיִײַ-ﬨשׁ-זּטּ-לּמּנּסּףּפּצּ-ﮱﯓ-ﴽﵐ-ﶏﶒ-ﷇﷰ-ﷻﹰ-ﹴﹶ-ﻼＡ-Ｚａ-ｚｦ-ﾾￂ-ￇￊ-ￏￒ-ￗￚ-ￜ]"),
            NonAsciiIdentifierPart: new RegExp("[ªµºÀ-ÖØ-öø-ˁˆ-ˑˠ-ˤˬˮ̀-ʹͶͷͺ-ͽΆΈ-ΊΌΎ-ΡΣ-ϵϷ-ҁ҃-҇Ҋ-ԧԱ-Ֆՙա-և֑-ׇֽֿׁׂׅׄא-תװ-ײؐ-ؚؠ-٩ٮ-ۓە-ۜ۟-۪ۨ-ۼۿܐ-݊ݍ-ޱ߀-ߵߺࠀ-࠭ࡀ-࡛ࢠࢢ-ࢬࣤ-ࣾऀ-ॣ०-९ॱ-ॷॹ-ॿঁ-ঃঅ-ঌএঐও-নপ-রলশ-হ়-ৄেৈো-ৎৗড়ঢ়য়-ৣ০-ৱਁ-ਃਅ-ਊਏਐਓ-ਨਪ-ਰਲਲ਼ਵਸ਼ਸਹ਼ਾ-ੂੇੈੋ-੍ੑਖ਼-ੜਫ਼੦-ੵઁ-ઃઅ-ઍએ-ઑઓ-નપ-રલળવ-હ઼-ૅે-ૉો-્ૐૠ-ૣ૦-૯ଁ-ଃଅ-ଌଏଐଓ-ନପ-ରଲଳଵ-ହ଼-ୄେୈୋ-୍ୖୗଡ଼ଢ଼ୟ-ୣ୦-୯ୱஂஃஅ-ஊஎ-ஐஒ-கஙசஜஞடணதந-பம-ஹா-ூெ-ைொ-்ௐௗ௦-௯ఁ-ఃఅ-ఌఎ-ఐఒ-నప-ళవ-హఽ-ౄె-ైొ-్ౕౖౘౙౠ-ౣ౦-౯ಂಃಅ-ಌಎ-ಐಒ-ನಪ-ಳವ-ಹ಼-ೄೆ-ೈೊ-್ೕೖೞೠ-ೣ೦-೯ೱೲംഃഅ-ഌഎ-ഐഒ-ഺഽ-ൄെ-ൈൊ-ൎൗൠ-ൣ൦-൯ൺ-ൿංඃඅ-ඖක-නඳ-රලව-ෆ්ා-ුූෘ-ෟෲෳก-ฺเ-๎๐-๙ກຂຄງຈຊຍດ-ທນ-ຟມ-ຣລວສຫອ-ູົ-ຽເ-ໄໆ່-ໍ໐-໙ໜ-ໟༀ༘༙༠-༩༹༵༷༾-ཇཉ-ཬཱ-྄྆-ྗྙ-ྼ࿆က-၉ၐ-ႝႠ-ჅჇჍა-ჺჼ-ቈቊ-ቍቐ-ቖቘቚ-ቝበ-ኈኊ-ኍነ-ኰኲ-ኵኸ-ኾዀዂ-ዅወ-ዖዘ-ጐጒ-ጕጘ-ፚ፝-፟ᎀ-ᎏᎠ-Ᏼᐁ-ᙬᙯ-ᙿᚁ-ᚚᚠ-ᛪᛮ-ᛰᜀ-ᜌᜎ-᜔ᜠ-᜴ᝀ-ᝓᝠ-ᝬᝮ-ᝰᝲᝳក-៓ៗៜ៝០-៩᠋-᠍᠐-᠙ᠠ-ᡷᢀ-ᢪᢰ-ᣵᤀ-ᤜᤠ-ᤫᤰ-᤻᥆-ᥭᥰ-ᥴᦀ-ᦫᦰ-ᧉ᧐-᧙ᨀ-ᨛᨠ-ᩞ᩠-᩿᩼-᪉᪐-᪙ᪧᬀ-ᭋ᭐-᭙᭫-᭳ᮀ-᯳ᰀ-᰷᱀-᱉ᱍ-ᱽ᳐-᳔᳒-ᳶᴀ-ᷦ᷼-ἕἘ-Ἕἠ-ὅὈ-Ὅὐ-ὗὙὛὝὟ-ώᾀ-ᾴᾶ-ᾼιῂ-ῄῆ-ῌῐ-ΐῖ-Ίῠ-Ῥῲ-ῴῶ-ῼ‌‍‿⁀⁔ⁱⁿₐ-ₜ⃐-⃥⃜⃡-⃰ℂℇℊ-ℓℕℙ-ℝℤΩℨK-ℭℯ-ℹℼ-ℿⅅ-ⅉⅎⅠ-ↈⰀ-Ⱞⰰ-ⱞⱠ-ⳤⳫ-ⳳⴀ-ⴥⴧⴭⴰ-ⵧⵯ⵿-ⶖⶠ-ⶦⶨ-ⶮⶰ-ⶶⶸ-ⶾⷀ-ⷆⷈ-ⷎⷐ-ⷖⷘ-ⷞⷠ-ⷿⸯ々-〇〡-〯〱-〵〸-〼ぁ-ゖ゙゚ゝ-ゟァ-ヺー-ヿㄅ-ㄭㄱ-ㆎㆠ-ㆺㇰ-ㇿ㐀-䶵一-鿌ꀀ-ꒌꓐ-ꓽꔀ-ꘌꘐ-ꘫꙀ-꙯ꙴ-꙽ꙿ-ꚗꚟ-꛱ꜗ-ꜟꜢ-ꞈꞋ-ꞎꞐ-ꞓꞠ-Ɦꟸ-ꠧꡀ-ꡳꢀ-꣄꣐-꣙꣠-ꣷꣻ꤀-꤭ꤰ-꥓ꥠ-ꥼꦀ-꧀ꧏ-꧙ꨀ-ꨶꩀ-ꩍ꩐-꩙ꩠ-ꩶꩺꩻꪀ-ꫂꫛ-ꫝꫠ-ꫯꫲ-꫶ꬁ-ꬆꬉ-ꬎꬑ-ꬖꬠ-ꬦꬨ-ꬮꯀ-ꯪ꯬꯭꯰-꯹가-힣ힰ-ퟆퟋ-ퟻ豈-舘並-龎ff-stﬓ-ﬗיִ-ﬨשׁ-זּטּ-לּמּנּסּףּפּצּ-ﮱﯓ-ﴽﵐ-ﶏﶒ-ﷇﷰ-ﷻ︀-️︠-︦︳︴﹍-﹏ﹰ-ﹴﹶ-ﻼ０-９Ａ-Ｚ＿ａ-ｚｦ-ﾾￂ-ￇￊ-ￏￒ-ￗￚ-ￜ]")
          };
          function assert(condition, message) {
            if (!condition) {
              throw new Error("ASSERT: " + message);
            }
          }
          function isDecimalDigit(ch) {
            return ch >= 48 && ch <= 57;
          }
          function isHexDigit(ch) {
            return "0123456789abcdefABCDEF".indexOf(ch) >= 0;
          }
          function isOctalDigit(ch) {
            return "01234567".indexOf(ch) >= 0;
          }
          function isWhiteSpace(ch) {
            return ch === 32 || ch === 9 || ch === 11 || ch === 12 || ch === 160 || ch >= 5760 && [5760, 6158, 8192, 8193, 8194, 8195, 8196, 8197, 8198, 8199, 8200, 8201, 8202, 8239, 8287, 12288, 65279].indexOf(ch) >= 0;
          }
          function isLineTerminator(ch) {
            return ch === 10 || ch === 13 || ch === 8232 || ch === 8233;
          }
          function isIdentifierStart(ch) {
            return ch == 64 || ch === 36 || ch === 95 || // $ (dollar) and _ (underscore)
            ch >= 65 && ch <= 90 || // A..Z
            ch >= 97 && ch <= 122 || // a..z
            ch === 92 || // \ (backslash)
            ch >= 128 && Regex.NonAsciiIdentifierStart.test(String.fromCharCode(ch));
          }
          function isIdentifierPart(ch) {
            return ch === 36 || ch === 95 || // $ (dollar) and _ (underscore)
            ch >= 65 && ch <= 90 || // A..Z
            ch >= 97 && ch <= 122 || // a..z
            ch >= 48 && ch <= 57 || // 0..9
            ch === 92 || // \ (backslash)
            ch >= 128 && Regex.NonAsciiIdentifierPart.test(String.fromCharCode(ch));
          }
          function isFutureReservedWord(id) {
            switch (id) {
              case "class":
              case "enum":
              case "export":
              case "extends":
              case "import":
              case "super":
                return true;
              default:
                return false;
            }
          }
          function isStrictModeReservedWord(id) {
            switch (id) {
              case "implements":
              case "interface":
              case "package":
              case "private":
              case "protected":
              case "public":
              case "static":
              case "yield":
              case "let":
                return true;
              default:
                return false;
            }
          }
          function isRestrictedWord(id) {
            return id === "eval" || id === "arguments";
          }
          function isKeyword(id) {
            if (strict && isStrictModeReservedWord(id)) {
              return true;
            }
            switch (id.length) {
              case 2:
                return id === "if" || id === "in" || id === "do";
              case 3:
                return id === "var" || id === "for" || id === "new" || id === "try" || id === "let";
              case 4:
                return id === "this" || id === "else" || id === "case" || id === "void" || id === "with" || id === "enum";
              case 5:
                return id === "while" || id === "break" || id === "catch" || id === "throw" || id === "const" || id === "yield" || id === "class" || id === "super";
              case 6:
                return id === "return" || id === "typeof" || id === "delete" || id === "switch" || id === "export" || id === "import";
              case 7:
                return id === "default" || id === "finally" || id === "extends";
              case 8:
                return id === "function" || id === "continue" || id === "debugger";
              case 10:
                return id === "instanceof";
              default:
                return false;
            }
          }
          function addComment(type, value, start, end, loc) {
            var comment;
            assert(typeof start === "number", "Comment must have valid position");
            if (state.lastCommentStart >= start) {
              return;
            }
            state.lastCommentStart = start;
            comment = {
              type,
              value
            };
            if (extra.range) {
              comment.range = [start, end];
            }
            if (extra.loc) {
              comment.loc = loc;
            }
            extra.comments.push(comment);
            if (extra.attachComment) {
              extra.leadingComments.push(comment);
              extra.trailingComments.push(comment);
            }
          }
          function skipSingleLineComment(offset) {
            var start, loc, ch, comment;
            start = index - offset;
            loc = {
              start: {
                line: lineNumber,
                column: index - lineStart - offset
              }
            };
            while (index < length) {
              ch = source.charCodeAt(index);
              ++index;
              if (isLineTerminator(ch)) {
                if (extra.comments) {
                  comment = source.slice(start + offset, index - 1);
                  loc.end = {
                    line: lineNumber,
                    column: index - lineStart - 1
                  };
                  addComment("Line", comment, start, index - 1, loc);
                }
                if (ch === 13 && source.charCodeAt(index) === 10) {
                  ++index;
                }
                ++lineNumber;
                lineStart = index;
                return;
              }
            }
            if (extra.comments) {
              comment = source.slice(start + offset, index);
              loc.end = {
                line: lineNumber,
                column: index - lineStart
              };
              addComment("Line", comment, start, index, loc);
            }
          }
          function skipMultiLineComment() {
            var start, loc, ch, comment;
            if (extra.comments) {
              start = index - 2;
              loc = {
                start: {
                  line: lineNumber,
                  column: index - lineStart - 2
                }
              };
            }
            while (index < length) {
              ch = source.charCodeAt(index);
              if (isLineTerminator(ch)) {
                if (ch === 13 && source.charCodeAt(index + 1) === 10) {
                  ++index;
                }
                ++lineNumber;
                ++index;
                lineStart = index;
                if (index >= length) {
                  throwError({}, Messages.UnexpectedToken, "ILLEGAL");
                }
              } else if (ch === 42) {
                if (source.charCodeAt(index + 1) === 47) {
                  ++index;
                  ++index;
                  if (extra.comments) {
                    comment = source.slice(start + 2, index - 2);
                    loc.end = {
                      line: lineNumber,
                      column: index - lineStart
                    };
                    addComment("Block", comment, start, index, loc);
                  }
                  return;
                }
                ++index;
              } else {
                ++index;
              }
            }
            throwError({}, Messages.UnexpectedToken, "ILLEGAL");
          }
          function skipComment() {
            var ch, start;
            start = index === 0;
            while (index < length) {
              ch = source.charCodeAt(index);
              if (isWhiteSpace(ch)) {
                ++index;
              } else if (isLineTerminator(ch)) {
                ++index;
                if (ch === 13 && source.charCodeAt(index) === 10) {
                  ++index;
                }
                ++lineNumber;
                lineStart = index;
                start = true;
              } else if (ch === 47) {
                ch = source.charCodeAt(index + 1);
                if (ch === 47) {
                  ++index;
                  ++index;
                  skipSingleLineComment(2);
                  start = true;
                } else if (ch === 42) {
                  ++index;
                  ++index;
                  skipMultiLineComment();
                } else {
                  break;
                }
              } else if (start && ch === 45) {
                if (source.charCodeAt(index + 1) === 45 && source.charCodeAt(index + 2) === 62) {
                  index += 3;
                  skipSingleLineComment(3);
                } else {
                  break;
                }
              } else if (ch === 60) {
                if (source.slice(index + 1, index + 4) === "!--") {
                  ++index;
                  ++index;
                  ++index;
                  ++index;
                  skipSingleLineComment(4);
                } else {
                  break;
                }
              } else {
                break;
              }
            }
          }
          function scanHexEscape(prefix) {
            var i, len, ch, code = 0;
            len = prefix === "u" ? 4 : 2;
            for (i = 0; i < len; ++i) {
              if (index < length && isHexDigit(source[index])) {
                ch = source[index++];
                code = code * 16 + "0123456789abcdef".indexOf(ch.toLowerCase());
              } else {
                return "";
              }
            }
            return String.fromCharCode(code);
          }
          function getEscapedIdentifier() {
            var ch, id;
            ch = source.charCodeAt(index++);
            id = String.fromCharCode(ch);
            if (ch === 92) {
              if (source.charCodeAt(index) !== 117) {
                throwError({}, Messages.UnexpectedToken, "ILLEGAL");
              }
              ++index;
              ch = scanHexEscape("u");
              if (!ch || ch === "\\" || !isIdentifierStart(ch.charCodeAt(0))) {
                throwError({}, Messages.UnexpectedToken, "ILLEGAL");
              }
              id = ch;
            }
            while (index < length) {
              ch = source.charCodeAt(index);
              if (!isIdentifierPart(ch)) {
                break;
              }
              ++index;
              id += String.fromCharCode(ch);
              if (ch === 92) {
                id = id.substr(0, id.length - 1);
                if (source.charCodeAt(index) !== 117) {
                  throwError({}, Messages.UnexpectedToken, "ILLEGAL");
                }
                ++index;
                ch = scanHexEscape("u");
                if (!ch || ch === "\\" || !isIdentifierPart(ch.charCodeAt(0))) {
                  throwError({}, Messages.UnexpectedToken, "ILLEGAL");
                }
                id += ch;
              }
            }
            return id;
          }
          function getIdentifier() {
            var start, ch;
            start = index++;
            while (index < length) {
              ch = source.charCodeAt(index);
              if (ch === 92) {
                index = start;
                return getEscapedIdentifier();
              }
              if (isIdentifierPart(ch)) {
                ++index;
              } else {
                break;
              }
            }
            return source.slice(start, index);
          }
          function scanIdentifier() {
            var start, id, type;
            start = index;
            id = source.charCodeAt(index) === 92 ? getEscapedIdentifier() : getIdentifier();
            if (id.length === 1) {
              type = Token.Identifier;
            } else if (isKeyword(id)) {
              type = Token.Keyword;
            } else if (id === "null") {
              type = Token.NullLiteral;
            } else if (id === "true" || id === "false") {
              type = Token.BooleanLiteral;
            } else {
              type = Token.Identifier;
            }
            return {
              type,
              value: id,
              lineNumber,
              lineStart,
              start,
              end: index
            };
          }
          function scanPunctuator() {
            var start = index, code = source.charCodeAt(index), code2, ch1 = source[index], ch2, ch3, ch4;
            switch (code) {
              // 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:
                ++index;
                if (extra.tokenize) {
                  if (code === 40) {
                    extra.openParenToken = extra.tokens.length;
                  } else if (code === 123) {
                    extra.openCurlyToken = extra.tokens.length;
                  }
                }
                return {
                  type: Token.Punctuator,
                  value: String.fromCharCode(code),
                  lineNumber,
                  lineStart,
                  start,
                  end: index
                };
              default:
                code2 = source.charCodeAt(index + 1);
                if (code2 === 61) {
                  switch (code) {
                    case 43:
                    // +
                    case 45:
                    // -
                    case 47:
                    // /
                    case 60:
                    // <
                    case 62:
                    // >
                    case 94:
                    // ^
                    case 124:
                    // |
                    case 37:
                    // %
                    case 38:
                    // &
                    case 42:
                      index += 2;
                      return {
                        type: Token.Punctuator,
                        value: String.fromCharCode(code) + String.fromCharCode(code2),
                        lineNumber,
                        lineStart,
                        start,
                        end: index
                      };
                    case 33:
                    // !
                    case 61:
                      index += 2;
                      if (source.charCodeAt(index) === 61) {
                        ++index;
                      }
                      return {
                        type: Token.Punctuator,
                        value: source.slice(start, index),
                        lineNumber,
                        lineStart,
                        start,
                        end: index
                      };
                  }
                }
            }
            ch4 = source.substr(index, 4);
            if (ch4 === ">>>=") {
              index += 4;
              return {
                type: Token.Punctuator,
                value: ch4,
                lineNumber,
                lineStart,
                start,
                end: index
              };
            }
            ch3 = ch4.substr(0, 3);
            if (ch3 === ">>>" || ch3 === "<<=" || ch3 === ">>=") {
              index += 3;
              return {
                type: Token.Punctuator,
                value: ch3,
                lineNumber,
                lineStart,
                start,
                end: index
              };
            }
            ch2 = ch3.substr(0, 2);
            if (ch1 === ch2[1] && "+-<>&|".indexOf(ch1) >= 0 || ch2 === "=>") {
              index += 2;
              return {
                type: Token.Punctuator,
                value: ch2,
                lineNumber,
                lineStart,
                start,
                end: index
              };
            }
            if ("<>=!+-*%&|^/".indexOf(ch1) >= 0) {
              ++index;
              return {
                type: Token.Punctuator,
                value: ch1,
                lineNumber,
                lineStart,
                start,
                end: index
              };
            }
            throwError({}, Messages.UnexpectedToken, "ILLEGAL");
          }
          function scanHexLiteral(start) {
            var number = "";
            while (index < length) {
              if (!isHexDigit(source[index])) {
                break;
              }
              number += source[index++];
            }
            if (number.length === 0) {
              throwError({}, Messages.UnexpectedToken, "ILLEGAL");
            }
            if (isIdentifierStart(source.charCodeAt(index))) {
              throwError({}, Messages.UnexpectedToken, "ILLEGAL");
            }
            return {
              type: Token.NumericLiteral,
              value: parseInt("0x" + number, 16),
              lineNumber,
              lineStart,
              start,
              end: index
            };
          }
          function scanOctalLiteral(start) {
            var number = "0" + source[index++];
            while (index < length) {
              if (!isOctalDigit(source[index])) {
                break;
              }
              number += source[index++];
            }
            if (isIdentifierStart(source.charCodeAt(index)) || isDecimalDigit(source.charCodeAt(index))) {
              throwError({}, Messages.UnexpectedToken, "ILLEGAL");
            }
            return {
              type: Token.NumericLiteral,
              value: parseInt(number, 8),
              octal: true,
              lineNumber,
              lineStart,
              start,
              end: index
            };
          }
          function scanNumericLiteral() {
            var number, start, ch;
            ch = source[index];
            assert(
              isDecimalDigit(ch.charCodeAt(0)) || ch === ".",
              "Numeric literal must start with a decimal digit or a decimal point"
            );
            start = index;
            number = "";
            if (ch !== ".") {
              number = source[index++];
              ch = source[index];
              if (number === "0") {
                if (ch === "x" || ch === "X") {
                  ++index;
                  return scanHexLiteral(start);
                }
                if (isOctalDigit(ch)) {
                  return scanOctalLiteral(start);
                }
                if (ch && isDecimalDigit(ch.charCodeAt(0))) {
                  throwError({}, Messages.UnexpectedToken, "ILLEGAL");
                }
              }
              while (isDecimalDigit(source.charCodeAt(index))) {
                number += source[index++];
              }
              ch = source[index];
            }
            if (ch === ".") {
              number += source[index++];
              while (isDecimalDigit(source.charCodeAt(index))) {
                number += source[index++];
              }
              ch = source[index];
            }
            if (ch === "e" || ch === "E") {
              number += source[index++];
              ch = source[index];
              if (ch === "+" || ch === "-") {
                number += source[index++];
              }
              if (isDecimalDigit(source.charCodeAt(index))) {
                while (isDecimalDigit(source.charCodeAt(index))) {
                  number += source[index++];
                }
              } else {
                throwError({}, Messages.UnexpectedToken, "ILLEGAL");
              }
            }
            if (isIdentifierStart(source.charCodeAt(index))) {
              throwError({}, Messages.UnexpectedToken, "ILLEGAL");
            }
            return {
              type: Token.NumericLiteral,
              value: parseFloat(number),
              lineNumber,
              lineStart,
              start,
              end: index
            };
          }
          function scanStringLiteral() {
            var str = "", quote, start, ch, code, unescaped, restore, octal = false, startLineNumber, startLineStart;
            startLineNumber = lineNumber;
            startLineStart = lineStart;
            quote = source[index];
            assert(
              quote === "'" || quote === '"',
              "String literal must starts with a quote"
            );
            start = index;
            ++index;
            while (index < length) {
              ch = source[index++];
              if (ch === quote) {
                quote = "";
                break;
              } else if (ch === "\\") {
                ch = source[index++];
                if (!ch || !isLineTerminator(ch.charCodeAt(0))) {
                  switch (ch) {
                    case "u":
                    case "x":
                      restore = index;
                      unescaped = scanHexEscape(ch);
                      if (unescaped) {
                        str += unescaped;
                      } else {
                        index = restore;
                        str += ch;
                      }
                      break;
                    case "n":
                      str += "\n";
                      break;
                    case "r":
                      str += "\r";
                      break;
                    case "t":
                      str += "	";
                      break;
                    case "b":
                      str += "\b";
                      break;
                    case "f":
                      str += "\f";
                      break;
                    case "v":
                      str += "\v";
                      break;
                    default:
                      if (isOctalDigit(ch)) {
                        code = "01234567".indexOf(ch);
                        if (code !== 0) {
                          octal = true;
                        }
                        if (index < length && isOctalDigit(source[index])) {
                          octal = true;
                          code = code * 8 + "01234567".indexOf(source[index++]);
                          if ("0123".indexOf(ch) >= 0 && index < length && isOctalDigit(source[index])) {
                            code = code * 8 + "01234567".indexOf(source[index++]);
                          }
                        }
                        str += String.fromCharCode(code);
                      } else {
                        str += ch;
                      }
                      break;
                  }
                } else {
                  ++lineNumber;
                  if (ch === "\r" && source[index] === "\n") {
                    ++index;
                  }
                  lineStart = index;
                }
              } else if (isLineTerminator(ch.charCodeAt(0))) {
                break;
              } else {
                str += ch;
              }
            }
            if (quote !== "") {
              throwError({}, Messages.UnexpectedToken, "ILLEGAL");
            }
            return {
              type: Token.StringLiteral,
              value: str,
              octal,
              startLineNumber,
              startLineStart,
              lineNumber,
              lineStart,
              start,
              end: index
            };
          }
          function testRegExp(pattern, flags) {
            var value;
            try {
              value = new RegExp(pattern, flags);
            } catch (e) {
              throwError({}, Messages.InvalidRegExp);
            }
            return value;
          }
          function scanRegExpBody() {
            var ch, str, classMarker, terminated, body;
            ch = source[index];
            assert(ch === "/", "Regular expression literal must start with a slash");
            str = source[index++];
            classMarker = false;
            terminated = false;
            while (index < length) {
              ch = source[index++];
              str += ch;
              if (ch === "\\") {
                ch = source[index++];
                if (isLineTerminator(ch.charCodeAt(0))) {
                  throwError({}, Messages.UnterminatedRegExp);
                }
                str += ch;
              } else if (isLineTerminator(ch.charCodeAt(0))) {
                throwError({}, Messages.UnterminatedRegExp);
              } else if (classMarker) {
                if (ch === "]") {
                  classMarker = false;
                }
              } else {
                if (ch === "/") {
                  terminated = true;
                  break;
                } else if (ch === "[") {
                  classMarker = true;
                }
              }
            }
            if (!terminated) {
              throwError({}, Messages.UnterminatedRegExp);
            }
            body = str.substr(1, str.length - 2);
            return {
              value: body,
              literal: str
            };
          }
          function scanRegExpFlags() {
            var ch, str, flags, restore;
            str = "";
            flags = "";
            while (index < length) {
              ch = source[index];
              if (!isIdentifierPart(ch.charCodeAt(0))) {
                break;
              }
              ++index;
              if (ch === "\\" && index < length) {
                ch = source[index];
                if (ch === "u") {
                  ++index;
                  restore = index;
                  ch = scanHexEscape("u");
                  if (ch) {
                    flags += ch;
                    for (str += "\\u"; restore < index; ++restore) {
                      str += source[restore];
                    }
                  } else {
                    index = restore;
                    flags += "u";
                    str += "\\u";
                  }
                  throwErrorTolerant({}, Messages.UnexpectedToken, "ILLEGAL");
                } else {
                  str += "\\";
                  throwErrorTolerant({}, Messages.UnexpectedToken, "ILLEGAL");
                }
              } else {
                flags += ch;
                str += ch;
              }
            }
            return {
              value: flags,
              literal: str
            };
          }
          function scanRegExp() {
            var start, body, flags, value;
            lookahead = null;
            skipComment();
            start = index;
            body = scanRegExpBody();
            flags = scanRegExpFlags();
            value = testRegExp(body.value, flags.value);
            if (extra.tokenize) {
              return {
                type: Token.RegularExpression,
                value,
                lineNumber,
                lineStart,
                start,
                end: index
              };
            }
            return {
              literal: body.literal + flags.literal,
              value,
              start,
              end: index
            };
          }
          function collectRegex() {
            var pos, loc, regex, token;
            skipComment();
            pos = index;
            loc = {
              start: {
                line: lineNumber,
                column: index - lineStart
              }
            };
            regex = scanRegExp();
            loc.end = {
              line: lineNumber,
              column: index - lineStart
            };
            if (!extra.tokenize) {
              if (extra.tokens.length > 0) {
                token = extra.tokens[extra.tokens.length - 1];
                if (token.range[0] === pos && token.type === "Punctuator") {
                  if (token.value === "/" || token.value === "/=") {
                    extra.tokens.pop();
                  }
                }
              }
              extra.tokens.push({
                type: "RegularExpression",
                value: regex.literal,
                range: [pos, index],
                loc
              });
            }
            return regex;
          }
          function isIdentifierName(token) {
            return token.type === Token.Identifier || token.type === Token.Keyword || token.type === Token.BooleanLiteral || token.type === Token.NullLiteral;
          }
          function advanceSlash() {
            var prevToken, checkToken;
            prevToken = extra.tokens[extra.tokens.length - 1];
            if (!prevToken) {
              return collectRegex();
            }
            if (prevToken.type === "Punctuator") {
              if (prevToken.value === "]") {
                return scanPunctuator();
              }
              if (prevToken.value === ")") {
                checkToken = extra.tokens[extra.openParenToken - 1];
                if (checkToken && checkToken.type === "Keyword" && (checkToken.value === "if" || checkToken.value === "while" || checkToken.value === "for" || checkToken.value === "with")) {
                  return collectRegex();
                }
                return scanPunctuator();
              }
              if (prevToken.value === "}") {
                if (extra.tokens[extra.openCurlyToken - 3] && extra.tokens[extra.openCurlyToken - 3].type === "Keyword") {
                  checkToken = extra.tokens[extra.openCurlyToken - 4];
                  if (!checkToken) {
                    return scanPunctuator();
                  }
                } else if (extra.tokens[extra.openCurlyToken - 4] && extra.tokens[extra.openCurlyToken - 4].type === "Keyword") {
                  checkToken = extra.tokens[extra.openCurlyToken - 5];
                  if (!checkToken) {
                    return collectRegex();
                  }
                } else {
                  return scanPunctuator();
                }
                if (FnExprTokens.indexOf(checkToken.value) >= 0) {
                  return scanPunctuator();
                }
                return collectRegex();
              }
              return collectRegex();
            }
            if (prevToken.type === "Keyword") {
              return collectRegex();
            }
            return scanPunctuator();
          }
          function advance() {
            var ch;
            skipComment();
            if (index >= length) {
              return {
                type: Token.EOF,
                lineNumber,
                lineStart,
                start: index,
                end: index
              };
            }
            ch = source.charCodeAt(index);
            if (isIdentifierStart(ch)) {
              return scanIdentifier();
            }
            if (ch === 40 || ch === 41 || ch === 59) {
              return scanPunctuator();
            }
            if (ch === 39 || ch === 34) {
              return scanStringLiteral();
            }
            if (ch === 46) {
              if (isDecimalDigit(source.charCodeAt(index + 1))) {
                return scanNumericLiteral();
              }
              return scanPunctuator();
            }
            if (isDecimalDigit(ch)) {
              return scanNumericLiteral();
            }
            if (extra.tokenize && ch === 47) {
              return advanceSlash();
            }
            return scanPunctuator();
          }
          function collectToken() {
            var loc, token, value;
            skipComment();
            loc = {
              start: {
                line: lineNumber,
                column: index - lineStart
              }
            };
            token = advance();
            loc.end = {
              line: lineNumber,
              column: index - lineStart
            };
            if (token.type !== Token.EOF) {
              value = source.slice(token.start, token.end);
              extra.tokens.push({
                type: TokenName[token.type],
                value,
                range: [token.start, token.end],
                loc
              });
            }
            return token;
          }
          function lex() {
            var token;
            token = lookahead;
            index = token.end;
            lineNumber = token.lineNumber;
            lineStart = token.lineStart;
            lookahead = typeof extra.tokens !== "undefined" ? collectToken() : advance();
            index = token.end;
            lineNumber = token.lineNumber;
            lineStart = token.lineStart;
            return token;
          }
          function peek() {
            var pos, line, start;
            pos = index;
            line = lineNumber;
            start = lineStart;
            lookahead = typeof extra.tokens !== "undefined" ? collectToken() : advance();
            index = pos;
            lineNumber = line;
            lineStart = start;
          }
          function Position(line, column) {
            this.line = line;
            this.column = column;
          }
          function SourceLocation(startLine, startColumn, line, column) {
            this.start = new Position(startLine, startColumn);
            this.end = new Position(line, column);
          }
          SyntaxTreeDelegate = {
            name: "SyntaxTree",
            processComment: function(node) {
              var lastChild, trailingComments;
              if (node.type === Syntax.Program) {
                if (node.body.length > 0) {
                  return;
                }
              }
              if (extra.trailingComments.length > 0) {
                if (extra.trailingComments[0].range[0] >= node.range[1]) {
                  trailingComments = extra.trailingComments;
                  extra.trailingComments = [];
                } else {
                  extra.trailingComments.length = 0;
                }
              } else {
                if (extra.bottomRightStack.length > 0 && extra.bottomRightStack[extra.bottomRightStack.length - 1].trailingComments && extra.bottomRightStack[extra.bottomRightStack.length - 1].trailingComments[0].range[0] >= node.range[1]) {
                  trailingComments = extra.bottomRightStack[extra.bottomRightStack.length - 1].trailingComments;
                  delete extra.bottomRightStack[extra.bottomRightStack.length - 1].trailingComments;
                }
              }
              while (extra.bottomRightStack.length > 0 && extra.bottomRightStack[extra.bottomRightStack.length - 1].range[0] >= node.range[0]) {
                lastChild = extra.bottomRightStack.pop();
              }
              if (lastChild) {
                if (lastChild.leadingComments && lastChild.leadingComments[lastChild.leadingComments.length - 1].range[1] <= node.range[0]) {
                  node.leadingComments = lastChild.leadingComments;
                  delete lastChild.leadingComments;
                }
              } else if (extra.leadingComments.length > 0 && extra.leadingComments[extra.leadingComments.length - 1].range[1] <= node.range[0]) {
                node.leadingComments = extra.leadingComments;
                extra.leadingComments = [];
              }
              if (trailingComments) {
                node.trailingComments = trailingComments;
              }
              extra.bottomRightStack.push(node);
            },
            markEnd: function(node, startToken) {
              if (extra.range) {
                node.range = [startToken.start, index];
              }
              if (extra.loc) {
                node.loc = new SourceLocation(
                  startToken.startLineNumber === void 0 ? startToken.lineNumber : startToken.startLineNumber,
                  startToken.start - (startToken.startLineStart === void 0 ? startToken.lineStart : startToken.startLineStart),
                  lineNumber,
                  index - lineStart
                );
                this.postProcess(node);
              }
              if (extra.attachComment) {
                this.processComment(node);
              }
              return node;
            },
            postProcess: function(node) {
              if (extra.source) {
                node.loc.source = extra.source;
              }
              return node;
            },
            createArrayExpression: function(elements) {
              return {
                type: Syntax.ArrayExpression,
                elements
              };
            },
            createAssignmentExpression: function(operator, left, right) {
              return {
                type: Syntax.AssignmentExpression,
                operator,
                left,
                right
              };
            },
            createBinaryExpression: function(operator, left, right) {
              var type = operator === "||" || operator === "&&" ? Syntax.LogicalExpression : Syntax.BinaryExpression;
              return {
                type,
                operator,
                left,
                right
              };
            },
            createBlockStatement: function(body) {
              return {
                type: Syntax.BlockStatement,
                body
              };
            },
            createBreakStatement: function(label) {
              return {
                type: Syntax.BreakStatement,
                label
              };
            },
            createCallExpression: function(callee, args) {
              return {
                type: Syntax.CallExpression,
                callee,
                "arguments": args
              };
            },
            createCatchClause: function(param, body) {
              return {
                type: Syntax.CatchClause,
                param,
                body
              };
            },
            createConditionalExpression: function(test, consequent, alternate) {
              return {
                type: Syntax.ConditionalExpression,
                test,
                consequent,
                alternate
              };
            },
            createContinueStatement: function(label) {
              return {
                type: Syntax.ContinueStatement,
                label
              };
            },
            createDebuggerStatement: function() {
              return {
                type: Syntax.DebuggerStatement
              };
            },
            createDoWhileStatement: function(body, test) {
              return {
                type: Syntax.DoWhileStatement,
                body,
                test
              };
            },
            createEmptyStatement: function() {
              return {
                type: Syntax.EmptyStatement
              };
            },
            createExpressionStatement: function(expression) {
              return {
                type: Syntax.ExpressionStatement,
                expression
              };
            },
            createForStatement: function(init, test, update, body) {
              return {
                type: Syntax.ForStatement,
                init,
                test,
                update,
                body
              };
            },
            createForInStatement: function(left, right, body) {
              return {
                type: Syntax.ForInStatement,
                left,
                right,
                body,
                each: false
              };
            },
            createFunctionDeclaration: function(id, params, defaults, body) {
              return {
                type: Syntax.FunctionDeclaration,
                id,
                params,
                defaults,
                body,
                rest: null,
                generator: false,
                expression: false
              };
            },
            createFunctionExpression: function(id, params, defaults, body) {
              return {
                type: Syntax.FunctionExpression,
                id,
                params,
                defaults,
                body,
                rest: null,
                generator: false,
                expression: false
              };
            },
            createIdentifier: function(name) {
              return {
                type: Syntax.Identifier,
                name
              };
            },
            createIfStatement: function(test, consequent, alternate) {
              return {
                type: Syntax.IfStatement,
                test,
                consequent,
                alternate
              };
            },
            createLabeledStatement: function(label, body) {
              return {
                type: Syntax.LabeledStatement,
                label,
                body
              };
            },
            createLiteral: function(token) {
              return {
                type: Syntax.Literal,
                value: token.value,
                raw: source.slice(token.start, token.end)
              };
            },
            createMemberExpression: function(accessor, object, property) {
              return {
                type: Syntax.MemberExpression,
                computed: accessor === "[",
                object,
                property
              };
            },
            createNewExpression: function(callee, args) {
              return {
                type: Syntax.NewExpression,
                callee,
                "arguments": args
              };
            },
            createObjectExpression: function(properties) {
              return {
                type: Syntax.ObjectExpression,
                properties
              };
            },
            createPostfixExpression: function(operator, argument) {
              return {
                type: Syntax.UpdateExpression,
                operator,
                argument,
                prefix: false
              };
            },
            createProgram: function(body) {
              return {
                type: Syntax.Program,
                body
              };
            },
            createProperty: function(kind, key, value) {
              return {
                type: Syntax.Property,
                key,
                value,
                kind
              };
            },
            createReturnStatement: function(argument) {
              return {
                type: Syntax.ReturnStatement,
                argument
              };
            },
            createSequenceExpression: function(expressions) {
              return {
                type: Syntax.SequenceExpression,
                expressions
              };
            },
            createSwitchCase: function(test, consequent) {
              return {
                type: Syntax.SwitchCase,
                test,
                consequent
              };
            },
            createSwitchStatement: function(discriminant, cases) {
              return {
                type: Syntax.SwitchStatement,
                discriminant,
                cases
              };
            },
            createThisExpression: function() {
              return {
                type: Syntax.ThisExpression
              };
            },
            createThrowStatement: function(argument) {
              return {
                type: Syntax.ThrowStatement,
                argument
              };
            },
            createTryStatement: function(block, guardedHandlers, handlers, finalizer) {
              return {
                type: Syntax.TryStatement,
                block,
                guardedHandlers,
                handlers,
                finalizer
              };
            },
            createUnaryExpression: function(operator, argument) {
              if (operator === "++" || operator === "--") {
                return {
                  type: Syntax.UpdateExpression,
                  operator,
                  argument,
                  prefix: true
                };
              }
              return {
                type: Syntax.UnaryExpression,
                operator,
                argument,
                prefix: true
              };
            },
            createVariableDeclaration: function(declarations, kind) {
              return {
                type: Syntax.VariableDeclaration,
                declarations,
                kind
              };
            },
            createVariableDeclarator: function(id, init) {
              return {
                type: Syntax.VariableDeclarator,
                id,
                init
              };
            },
            createWhileStatement: function(test, body) {
              return {
                type: Syntax.WhileStatement,
                test,
                body
              };
            },
            createWithStatement: function(object, body) {
              return {
                type: Syntax.WithStatement,
                object,
                body
              };
            }
          };
          function peekLineTerminator() {
            var pos, line, start, found;
            pos = index;
            line = lineNumber;
            start = lineStart;
            skipComment();
            found = lineNumber !== line;
            index = pos;
            lineNumber = line;
            lineStart = start;
            return found;
          }
          function throwError(token, messageFormat) {
            var error, args = Array.prototype.slice.call(arguments, 2), msg = messageFormat.replace(
              /%(\d)/g,
              function(whole, index2) {
                assert(index2 < args.length, "Message reference must be in range");
                return args[index2];
              }
            );
            if (typeof token.lineNumber === "number") {
              error = new Error("Line " + token.lineNumber + ": " + msg);
              error.index = token.start;
              error.lineNumber = token.lineNumber;
              error.column = token.start - lineStart + 1;
            } else {
              error = new Error("Line " + lineNumber + ": " + msg);
              error.index = index;
              error.lineNumber = lineNumber;
              error.column = index - lineStart + 1;
            }
            error.description = msg;
            throw error;
          }
          function throwErrorTolerant() {
            try {
              throwError.apply(null, arguments);
            } catch (e) {
              if (extra.errors) {
                extra.errors.push(e);
              } else {
                throw e;
              }
            }
          }
          function throwUnexpected(token) {
            if (token.type === Token.EOF) {
              throwError(token, Messages.UnexpectedEOS);
            }
            if (token.type === Token.NumericLiteral) {
              throwError(token, Messages.UnexpectedNumber);
            }
            if (token.type === Token.StringLiteral) {
              throwError(token, Messages.UnexpectedString);
            }
            if (token.type === Token.Identifier) {
              throwError(token, Messages.UnexpectedIdentifier);
            }
            if (token.type === Token.Keyword) {
              if (isFutureReservedWord(token.value)) {
                throwError(token, Messages.UnexpectedReserved);
              } else if (strict && isStrictModeReservedWord(token.value)) {
                throwErrorTolerant(token, Messages.StrictReservedWord);
                return;
              }
              throwError(token, Messages.UnexpectedToken, token.value);
            }
            throwError(token, Messages.UnexpectedToken, token.value);
          }
          function expect(value) {
            var token = lex();
            if (token.type !== Token.Punctuator || token.value !== value) {
              throwUnexpected(token);
            }
          }
          function expectKeyword(keyword) {
            var token = lex();
            if (token.type !== Token.Keyword || token.value !== keyword) {
              throwUnexpected(token);
            }
          }
          function match(value) {
            return lookahead.type === Token.Punctuator && lookahead.value === value;
          }
          function matchKeyword(keyword) {
            return lookahead.type === Token.Keyword && lookahead.value === keyword;
          }
          function matchAssign() {
            var op;
            if (lookahead.type !== Token.Punctuator) {
              return false;
            }
            op = lookahead.value;
            return op === "=" || op === "*=" || op === "/=" || op === "%=" || op === "+=" || op === "-=" || op === "<<=" || op === ">>=" || op === ">>>=" || op === "&=" || op === "^=" || op === "|=";
          }
          function consumeSemicolon() {
            var line;
            if (source.charCodeAt(index) === 59 || match(";")) {
              lex();
              return;
            }
            line = lineNumber;
            skipComment();
            if (lineNumber !== line) {
              return;
            }
            if (lookahead.type !== Token.EOF && !match("}")) {
              throwUnexpected(lookahead);
            }
          }
          function isLeftHandSide(expr) {
            return expr.type === Syntax.Identifier || expr.type === Syntax.MemberExpression;
          }
          function parseArrayInitialiser() {
            var elements = [], startToken;
            startToken = lookahead;
            expect("[");
            while (!match("]")) {
              if (match(",")) {
                lex();
                elements.push(null);
              } else {
                elements.push(parseAssignmentExpression());
                if (!match("]")) {
                  expect(",");
                }
              }
            }
            lex();
            return delegate.markEnd(delegate.createArrayExpression(elements), startToken);
          }
          function parsePropertyFunction(param, first) {
            var previousStrict, body, startToken;
            previousStrict = strict;
            startToken = lookahead;
            body = parseFunctionSourceElements();
            if (first && strict && isRestrictedWord(param[0].name)) {
              throwErrorTolerant(first, Messages.StrictParamName);
            }
            strict = previousStrict;
            return delegate.markEnd(delegate.createFunctionExpression(null, param, [], body), startToken);
          }
          function parseObjectPropertyKey() {
            var token, startToken;
            startToken = lookahead;
            token = lex();
            if (token.type === Token.StringLiteral || token.type === Token.NumericLiteral) {
              if (strict && token.octal) {
                throwErrorTolerant(token, Messages.StrictOctalLiteral);
              }
              return delegate.markEnd(delegate.createLiteral(token), startToken);
            }
            return delegate.markEnd(delegate.createIdentifier(token.value), startToken);
          }
          function parseObjectProperty() {
            var token, key, id, value, param, startToken;
            token = lookahead;
            startToken = lookahead;
            if (token.type === Token.Identifier) {
              id = parseObjectPropertyKey();
              if (token.value === "get" && !match(":")) {
                key = parseObjectPropertyKey();
                expect("(");
                expect(")");
                value = parsePropertyFunction([]);
                return delegate.markEnd(delegate.createProperty("get", key, value), startToken);
              }
              if (token.value === "set" && !match(":")) {
                key = parseObjectPropertyKey();
                expect("(");
                token = lookahead;
                if (token.type !== Token.Identifier) {
                  expect(")");
                  throwErrorTolerant(token, Messages.UnexpectedToken, token.value);
                  value = parsePropertyFunction([]);
                } else {
                  param = [parseVariableIdentifier()];
                  expect(")");
                  value = parsePropertyFunction(param, token);
                }
                return delegate.markEnd(delegate.createProperty("set", key, value), startToken);
              }
              expect(":");
              value = parseAssignmentExpression();
              return delegate.markEnd(delegate.createProperty("init", id, value), startToken);
            }
            if (token.type === Token.EOF || token.type === Token.Punctuator) {
              throwUnexpected(token);
            } else {
              key = parseObjectPropertyKey();
              expect(":");
              value = parseAssignmentExpression();
              return delegate.markEnd(delegate.createProperty("init", key, value), startToken);
            }
          }
          function parseObjectInitialiser() {
            var properties = [], property, name, key, kind, map = {}, toString = String, startToken;
            startToken = lookahead;
            expect("{");
            while (!match("}")) {
              property = parseObjectProperty();
              if (property.key.type === Syntax.Identifier) {
                name = property.key.name;
              } else {
                name = toString(property.key.value);
              }
              kind = property.kind === "init" ? PropertyKind.Data : property.kind === "get" ? PropertyKind.Get : PropertyKind.Set;
              key = "$" + name;
              if (Object.prototype.hasOwnProperty.call(map, key)) {
                if (map[key] === PropertyKind.Data) {
                  if (strict && kind === PropertyKind.Data) {
                    throwErrorTolerant({}, Messages.StrictDuplicateProperty);
                  } else if (kind !== PropertyKind.Data) {
                    throwErrorTolerant({}, Messages.AccessorDataProperty);
                  }
                } else {
                  if (kind === PropertyKind.Data) {
                    throwErrorTolerant({}, Messages.AccessorDataProperty);
                  } else if (map[key] & kind) {
                    throwErrorTolerant({}, Messages.AccessorGetSet);
                  }
                }
                map[key] |= kind;
              } else {
                map[key] = kind;
              }
              properties.push(property);
              if (!match("}")) {
                expect(",");
              }
            }
            expect("}");
            return delegate.markEnd(delegate.createObjectExpression(properties), startToken);
          }
          function parseGroupExpression() {
            var expr;
            expect("(");
            expr = parseExpression();
            expect(")");
            return expr;
          }
          function parsePrimaryExpression() {
            var type, token, expr, startToken;
            if (match("(")) {
              return parseGroupExpression();
            }
            if (match("[")) {
              return parseArrayInitialiser();
            }
            if (match("{")) {
              return parseObjectInitialiser();
            }
            type = lookahead.type;
            startToken = lookahead;
            if (type === Token.Identifier) {
              expr = delegate.createIdentifier(lex().value);
            } else if (type === Token.StringLiteral || type === Token.NumericLiteral) {
              if (strict && lookahead.octal) {
                throwErrorTolerant(lookahead, Messages.StrictOctalLiteral);
              }
              expr = delegate.createLiteral(lex());
            } else if (type === Token.Keyword) {
              if (matchKeyword("function")) {
                return parseFunctionExpression();
              }
              if (matchKeyword("this")) {
                lex();
                expr = delegate.createThisExpression();
              } else {
                throwUnexpected(lex());
              }
            } else if (type === Token.BooleanLiteral) {
              token = lex();
              token.value = token.value === "true";
              expr = delegate.createLiteral(token);
            } else if (type === Token.NullLiteral) {
              token = lex();
              token.value = null;
              expr = delegate.createLiteral(token);
            } else if (match("/") || match("/=")) {
              if (typeof extra.tokens !== "undefined") {
                expr = delegate.createLiteral(collectRegex());
              } else {
                expr = delegate.createLiteral(scanRegExp());
              }
              peek();
            } else {
              throwUnexpected(lex());
            }
            return delegate.markEnd(expr, startToken);
          }
          function parseArguments() {
            var args = [];
            expect("(");
            if (!match(")")) {
              while (index < length) {
                args.push(parseAssignmentExpression());
                if (match(")")) {
                  break;
                }
                expect(",");
              }
            }
            expect(")");
            return args;
          }
          function parseNonComputedProperty() {
            var token, startToken;
            startToken = lookahead;
            token = lex();
            if (!isIdentifierName(token)) {
              throwUnexpected(token);
            }
            return delegate.markEnd(delegate.createIdentifier(token.value), startToken);
          }
          function parseNonComputedMember() {
            expect(".");
            return parseNonComputedProperty();
          }
          function parseComputedMember() {
            var expr;
            expect("[");
            expr = parseExpression();
            expect("]");
            return expr;
          }
          function parseNewExpression() {
            var callee, args, startToken;
            startToken = lookahead;
            expectKeyword("new");
            callee = parseLeftHandSideExpression();
            args = match("(") ? parseArguments() : [];
            return delegate.markEnd(delegate.createNewExpression(callee, args), startToken);
          }
          function parseLeftHandSideExpressionAllowCall() {
            var previousAllowIn, expr, args, property, startToken;
            startToken = lookahead;
            previousAllowIn = state.allowIn;
            state.allowIn = true;
            expr = matchKeyword("new") ? parseNewExpression() : parsePrimaryExpression();
            state.allowIn = previousAllowIn;
            for (; ; ) {
              if (match(".")) {
                property = parseNonComputedMember();
                expr = delegate.createMemberExpression(".", expr, property);
              } else if (match("(")) {
                args = parseArguments();
                expr = delegate.createCallExpression(expr, args);
              } else if (match("[")) {
                property = parseComputedMember();
                expr = delegate.createMemberExpression("[", expr, property);
              } else {
                break;
              }
              delegate.markEnd(expr, startToken);
            }
            return expr;
          }
          function parseLeftHandSideExpression() {
            var previousAllowIn, expr, property, startToken;
            startToken = lookahead;
            previousAllowIn = state.allowIn;
            expr = matchKeyword("new") ? parseNewExpression() : parsePrimaryExpression();
            state.allowIn = previousAllowIn;
            while (match(".") || match("[")) {
              if (match("[")) {
                property = parseComputedMember();
                expr = delegate.createMemberExpression("[", expr, property);
              } else {
                property = parseNonComputedMember();
                expr = delegate.createMemberExpression(".", expr, property);
              }
              delegate.markEnd(expr, startToken);
            }
            return expr;
          }
          function parsePostfixExpression() {
            var expr, token, startToken = lookahead;
            expr = parseLeftHandSideExpressionAllowCall();
            if (lookahead.type === Token.Punctuator) {
              if ((match("++") || match("--")) && !peekLineTerminator()) {
                if (strict && expr.type === Syntax.Identifier && isRestrictedWord(expr.name)) {
                  throwErrorTolerant({}, Messages.StrictLHSPostfix);
                }
                if (!isLeftHandSide(expr)) {
                  throwErrorTolerant({}, Messages.InvalidLHSInAssignment);
                }
                token = lex();
                expr = delegate.markEnd(delegate.createPostfixExpression(token.value, expr), startToken);
              }
            }
            return expr;
          }
          function parseUnaryExpression() {
            var token, expr, startToken;
            if (lookahead.type !== Token.Punctuator && lookahead.type !== Token.Keyword) {
              expr = parsePostfixExpression();
            } else if (match("++") || match("--")) {
              startToken = lookahead;
              token = lex();
              expr = parseUnaryExpression();
              if (strict && expr.type === Syntax.Identifier && isRestrictedWord(expr.name)) {
                throwErrorTolerant({}, Messages.StrictLHSPrefix);
              }
              if (!isLeftHandSide(expr)) {
                throwErrorTolerant({}, Messages.InvalidLHSInAssignment);
              }
              expr = delegate.createUnaryExpression(token.value, expr);
              expr = delegate.markEnd(expr, startToken);
            } else if (match("+") || match("-") || match("~") || match("!")) {
              startToken = lookahead;
              token = lex();
              expr = parseUnaryExpression();
              expr = delegate.createUnaryExpression(token.value, expr);
              expr = delegate.markEnd(expr, startToken);
            } else if (matchKeyword("delete") || matchKeyword("void") || matchKeyword("typeof")) {
              startToken = lookahead;
              token = lex();
              expr = parseUnaryExpression();
              expr = delegate.createUnaryExpression(token.value, expr);
              expr = delegate.markEnd(expr, startToken);
              if (strict && expr.operator === "delete" && expr.argument.type === Syntax.Identifier) {
                throwErrorTolerant({}, Messages.StrictDelete);
              }
            } else {
              expr = parsePostfixExpression();
            }
            return expr;
          }
          function binaryPrecedence(token, allowIn) {
            var prec = 0;
            if (token.type !== Token.Punctuator && token.type !== Token.Keyword) {
              return 0;
            }
            switch (token.value) {
              case "||":
                prec = 1;
                break;
              case "&&":
                prec = 2;
                break;
              case "|":
                prec = 3;
                break;
              case "^":
                prec = 4;
                break;
              case "&":
                prec = 5;
                break;
              case "==":
              case "!=":
              case "===":
              case "!==":
                prec = 6;
                break;
              case "<":
              case ">":
              case "<=":
              case ">=":
              case "instanceof":
                prec = 7;
                break;
              case "in":
                prec = allowIn ? 7 : 0;
                break;
              case "<<":
              case ">>":
              case ">>>":
                prec = 8;
                break;
              case "+":
              case "-":
                prec = 9;
                break;
              case "*":
              case "/":
              case "%":
                prec = 11;
                break;
            }
            return prec;
          }
          function parseBinaryExpression() {
            var marker, markers, expr, token, prec, stack, right, operator, left, i;
            marker = lookahead;
            left = parseUnaryExpression();
            token = lookahead;
            prec = binaryPrecedence(token, state.allowIn);
            if (prec === 0) {
              return left;
            }
            token.prec = prec;
            lex();
            markers = [marker, lookahead];
            right = parseUnaryExpression();
            stack = [left, token, right];
            while ((prec = binaryPrecedence(lookahead, state.allowIn)) > 0) {
              while (stack.length > 2 && prec <= stack[stack.length - 2].prec) {
                right = stack.pop();
                operator = stack.pop().value;
                left = stack.pop();
                expr = delegate.createBinaryExpression(operator, left, right);
                markers.pop();
                marker = markers[markers.length - 1];
                delegate.markEnd(expr, marker);
                stack.push(expr);
              }
              token = lex();
              token.prec = prec;
              stack.push(token);
              markers.push(lookahead);
              expr = parseUnaryExpression();
              stack.push(expr);
            }
            i = stack.length - 1;
            expr = stack[i];
            markers.pop();
            while (i > 1) {
              expr = delegate.createBinaryExpression(stack[i - 1].value, stack[i - 2], expr);
              i -= 2;
              marker = markers.pop();
              delegate.markEnd(expr, marker);
            }
            return expr;
          }
          function parseConditionalExpression() {
            var expr, previousAllowIn, consequent, alternate, startToken;
            startToken = lookahead;
            expr = parseBinaryExpression();
            if (match("?")) {
              lex();
              previousAllowIn = state.allowIn;
              state.allowIn = true;
              consequent = parseAssignmentExpression();
              state.allowIn = previousAllowIn;
              expect(":");
              alternate = parseAssignmentExpression();
              expr = delegate.createConditionalExpression(expr, consequent, alternate);
              delegate.markEnd(expr, startToken);
            }
            return expr;
          }
          function parseAssignmentExpression() {
            var token, left, right, node, startToken;
            token = lookahead;
            startToken = lookahead;
            node = left = parseConditionalExpression();
            if (matchAssign()) {
              if (!isLeftHandSide(left)) {
                throwErrorTolerant({}, Messages.InvalidLHSInAssignment);
              }
              if (strict && left.type === Syntax.Identifier && isRestrictedWord(left.name)) {
                throwErrorTolerant(token, Messages.StrictLHSAssignment);
              }
              token = lex();
              right = parseAssignmentExpression();
              node = delegate.markEnd(delegate.createAssignmentExpression(token.value, left, right), startToken);
            }
            return node;
          }
          function parseExpression() {
            var expr, startToken = lookahead;
            expr = parseAssignmentExpression();
            if (match(",")) {
              expr = delegate.createSequenceExpression([expr]);
              while (index < length) {
                if (!match(",")) {
                  break;
                }
                lex();
                expr.expressions.push(parseAssignmentExpression());
              }
              delegate.markEnd(expr, startToken);
            }
            return expr;
          }
          function parseStatementList() {
            var list = [], statement;
            while (index < length) {
              if (match("}")) {
                break;
              }
              statement = parseSourceElement();
              if (typeof statement === "undefined") {
                break;
              }
              list.push(statement);
            }
            return list;
          }
          function parseBlock() {
            var block, startToken;
            startToken = lookahead;
            expect("{");
            block = parseStatementList();
            expect("}");
            return delegate.markEnd(delegate.createBlockStatement(block), startToken);
          }
          function parseVariableIdentifier() {
            var token, startToken;
            startToken = lookahead;
            token = lex();
            if (token.type !== Token.Identifier) {
              throwUnexpected(token);
            }
            return delegate.markEnd(delegate.createIdentifier(token.value), startToken);
          }
          function parseVariableDeclaration(kind) {
            var init = null, id, startToken;
            startToken = lookahead;
            id = parseVariableIdentifier();
            if (strict && isRestrictedWord(id.name)) {
              throwErrorTolerant({}, Messages.StrictVarName);
            }
            if (kind === "const") {
              expect("=");
              init = parseAssignmentExpression();
            } else if (match("=")) {
              lex();
              init = parseAssignmentExpression();
            }
            return delegate.markEnd(delegate.createVariableDeclarator(id, init), startToken);
          }
          function parseVariableDeclarationList(kind) {
            var list = [];
            do {
              list.push(parseVariableDeclaration(kind));
              if (!match(",")) {
                break;
              }
              lex();
            } while (index < length);
            return list;
          }
          function parseVariableStatement() {
            var declarations;
            expectKeyword("var");
            declarations = parseVariableDeclarationList();
            consumeSemicolon();
            return delegate.createVariableDeclaration(declarations, "var");
          }
          function parseConstLetDeclaration(kind) {
            var declarations, startToken;
            startToken = lookahead;
            expectKeyword(kind);
            declarations = parseVariableDeclarationList(kind);
            consumeSemicolon();
            return delegate.markEnd(delegate.createVariableDeclaration(declarations, kind), startToken);
          }
          function parseEmptyStatement() {
            expect(";");
            return delegate.createEmptyStatement();
          }
          function parseExpressionStatement() {
            var expr = parseExpression();
            consumeSemicolon();
            return delegate.createExpressionStatement(expr);
          }
          function parseIfStatement() {
            var test, consequent, alternate;
            expectKeyword("if");
            expect("(");
            test = parseExpression();
            expect(")");
            consequent = parseStatement();
            if (matchKeyword("else")) {
              lex();
              alternate = parseStatement();
            } else {
              alternate = null;
            }
            return delegate.createIfStatement(test, consequent, alternate);
          }
          function parseDoWhileStatement() {
            var body, test, oldInIteration;
            expectKeyword("do");
            oldInIteration = state.inIteration;
            state.inIteration = true;
            body = parseStatement();
            state.inIteration = oldInIteration;
            expectKeyword("while");
            expect("(");
            test = parseExpression();
            expect(")");
            if (match(";")) {
              lex();
            }
            return delegate.createDoWhileStatement(body, test);
          }
          function parseWhileStatement() {
            var test, body, oldInIteration;
            expectKeyword("while");
            expect("(");
            test = parseExpression();
            expect(")");
            oldInIteration = state.inIteration;
            state.inIteration = true;
            body = parseStatement();
            state.inIteration = oldInIteration;
            return delegate.createWhileStatement(test, body);
          }
          function parseForVariableDeclaration() {
            var token, declarations, startToken;
            startToken = lookahead;
            token = lex();
            declarations = parseVariableDeclarationList();
            return delegate.markEnd(delegate.createVariableDeclaration(declarations, token.value), startToken);
          }
          function parseForStatement() {
            var init, test, update, left, right, body, oldInIteration;
            init = test = update = null;
            expectKeyword("for");
            expect("(");
            if (match(";")) {
              lex();
            } else {
              if (matchKeyword("var") || matchKeyword("let")) {
                state.allowIn = false;
                init = parseForVariableDeclaration();
                state.allowIn = true;
                if (init.declarations.length === 1 && matchKeyword("in")) {
                  lex();
                  left = init;
                  right = parseExpression();
                  init = null;
                }
              } else {
                state.allowIn = false;
                init = parseExpression();
                state.allowIn = true;
                if (matchKeyword("in")) {
                  if (!isLeftHandSide(init)) {
                    throwErrorTolerant({}, Messages.InvalidLHSInForIn);
                  }
                  lex();
                  left = init;
                  right = parseExpression();
                  init = null;
                }
              }
              if (typeof left === "undefined") {
                expect(";");
              }
            }
            if (typeof left === "undefined") {
              if (!match(";")) {
                test = parseExpression();
              }
              expect(";");
              if (!match(")")) {
                update = parseExpression();
              }
            }
            expect(")");
            oldInIteration = state.inIteration;
            state.inIteration = true;
            body = parseStatement();
            state.inIteration = oldInIteration;
            return typeof left === "undefined" ? delegate.createForStatement(init, test, update, body) : delegate.createForInStatement(left, right, body);
          }
          function parseContinueStatement() {
            var label = null, key;
            expectKeyword("continue");
            if (source.charCodeAt(index) === 59) {
              lex();
              if (!state.inIteration) {
                throwError({}, Messages.IllegalContinue);
              }
              return delegate.createContinueStatement(null);
            }
            if (peekLineTerminator()) {
              if (!state.inIteration) {
                throwError({}, Messages.IllegalContinue);
              }
              return delegate.createContinueStatement(null);
            }
            if (lookahead.type === Token.Identifier) {
              label = parseVariableIdentifier();
              key = "$" + label.name;
              if (!Object.prototype.hasOwnProperty.call(state.labelSet, key)) {
                throwError({}, Messages.UnknownLabel, label.name);
              }
            }
            consumeSemicolon();
            if (label === null && !state.inIteration) {
              throwError({}, Messages.IllegalContinue);
            }
            return delegate.createContinueStatement(label);
          }
          function parseBreakStatement() {
            var label = null, key;
            expectKeyword("break");
            if (source.charCodeAt(index) === 59) {
              lex();
              if (!(state.inIteration || state.inSwitch)) {
                throwError({}, Messages.IllegalBreak);
              }
              return delegate.createBreakStatement(null);
            }
            if (peekLineTerminator()) {
              if (!(state.inIteration || state.inSwitch)) {
                throwError({}, Messages.IllegalBreak);
              }
              return delegate.createBreakStatement(null);
            }
            if (lookahead.type === Token.Identifier) {
              label = parseVariableIdentifier();
              key = "$" + label.name;
              if (!Object.prototype.hasOwnProperty.call(state.labelSet, key)) {
                throwError({}, Messages.UnknownLabel, label.name);
              }
            }
            consumeSemicolon();
            if (label === null && !(state.inIteration || state.inSwitch)) {
              throwError({}, Messages.IllegalBreak);
            }
            return delegate.createBreakStatement(label);
          }
          function parseReturnStatement() {
            var argument = null;
            expectKeyword("return");
            if (!state.inFunctionBody) {
              throwErrorTolerant({}, Messages.IllegalReturn);
            }
            if (source.charCodeAt(index) === 32) {
              if (isIdentifierStart(source.charCodeAt(index + 1))) {
                argument = parseExpression();
                consumeSemicolon();
                return delegate.createReturnStatement(argument);
              }
            }
            if (peekLineTerminator()) {
              return delegate.createReturnStatement(null);
            }
            if (!match(";")) {
              if (!match("}") && lookahead.type !== Token.EOF) {
                argument = parseExpression();
              }
            }
            consumeSemicolon();
            return delegate.createReturnStatement(argument);
          }
          function parseWithStatement() {
            var object, body;
            if (strict) {
              skipComment();
              throwErrorTolerant({}, Messages.StrictModeWith);
            }
            expectKeyword("with");
            expect("(");
            object = parseExpression();
            expect(")");
            body = parseStatement();
            return delegate.createWithStatement(object, body);
          }
          function parseSwitchCase() {
            var test, consequent = [], statement, startToken;
            startToken = lookahead;
            if (matchKeyword("default")) {
              lex();
              test = null;
            } else {
              expectKeyword("case");
              test = parseExpression();
            }
            expect(":");
            while (index < length) {
              if (match("}") || matchKeyword("default") || matchKeyword("case")) {
                break;
              }
              statement = parseStatement();
              consequent.push(statement);
            }
            return delegate.markEnd(delegate.createSwitchCase(test, consequent), startToken);
          }
          function parseSwitchStatement() {
            var discriminant, cases, clause, oldInSwitch, defaultFound;
            expectKeyword("switch");
            expect("(");
            discriminant = parseExpression();
            expect(")");
            expect("{");
            cases = [];
            if (match("}")) {
              lex();
              return delegate.createSwitchStatement(discriminant, cases);
            }
            oldInSwitch = state.inSwitch;
            state.inSwitch = true;
            defaultFound = false;
            while (index < length) {
              if (match("}")) {
                break;
              }
              clause = parseSwitchCase();
              if (clause.test === null) {
                if (defaultFound) {
                  throwError({}, Messages.MultipleDefaultsInSwitch);
                }
                defaultFound = true;
              }
              cases.push(clause);
            }
            state.inSwitch = oldInSwitch;
            expect("}");
            return delegate.createSwitchStatement(discriminant, cases);
          }
          function parseThrowStatement() {
            var argument;
            expectKeyword("throw");
            if (peekLineTerminator()) {
              throwError({}, Messages.NewlineAfterThrow);
            }
            argument = parseExpression();
            consumeSemicolon();
            return delegate.createThrowStatement(argument);
          }
          function parseCatchClause() {
            var param, body, startToken;
            startToken = lookahead;
            expectKeyword("catch");
            expect("(");
            if (match(")")) {
              throwUnexpected(lookahead);
            }
            param = parseVariableIdentifier();
            if (strict && isRestrictedWord(param.name)) {
              throwErrorTolerant({}, Messages.StrictCatchVariable);
            }
            expect(")");
            body = parseBlock();
            return delegate.markEnd(delegate.createCatchClause(param, body), startToken);
          }
          function parseTryStatement() {
            var block, handlers = [], finalizer = null;
            expectKeyword("try");
            block = parseBlock();
            if (matchKeyword("catch")) {
              handlers.push(parseCatchClause());
            }
            if (matchKeyword("finally")) {
              lex();
              finalizer = parseBlock();
            }
            if (handlers.length === 0 && !finalizer) {
              throwError({}, Messages.NoCatchOrFinally);
            }
            return delegate.createTryStatement(block, [], handlers, finalizer);
          }
          function parseDebuggerStatement() {
            expectKeyword("debugger");
            consumeSemicolon();
            return delegate.createDebuggerStatement();
          }
          function parseStatement() {
            var type = lookahead.type, expr, labeledBody, key, startToken;
            if (type === Token.EOF) {
              throwUnexpected(lookahead);
            }
            if (type === Token.Punctuator && lookahead.value === "{") {
              return parseBlock();
            }
            startToken = lookahead;
            if (type === Token.Punctuator) {
              switch (lookahead.value) {
                case ";":
                  return delegate.markEnd(parseEmptyStatement(), startToken);
                case "(":
                  return delegate.markEnd(parseExpressionStatement(), startToken);
              }
            }
            if (type === Token.Keyword) {
              switch (lookahead.value) {
                case "break":
                  return delegate.markEnd(parseBreakStatement(), startToken);
                case "continue":
                  return delegate.markEnd(parseContinueStatement(), startToken);
                case "debugger":
                  return delegate.markEnd(parseDebuggerStatement(), startToken);
                case "do":
                  return delegate.markEnd(parseDoWhileStatement(), startToken);
                case "for":
                  return delegate.markEnd(parseForStatement(), startToken);
                case "function":
                  return delegate.markEnd(parseFunctionDeclaration(), startToken);
                case "if":
                  return delegate.markEnd(parseIfStatement(), startToken);
                case "return":
                  return delegate.markEnd(parseReturnStatement(), startToken);
                case "switch":
                  return delegate.markEnd(parseSwitchStatement(), startToken);
                case "throw":
                  return delegate.markEnd(parseThrowStatement(), startToken);
                case "try":
                  return delegate.markEnd(parseTryStatement(), startToken);
                case "var":
                  return delegate.markEnd(parseVariableStatement(), startToken);
                case "while":
                  return delegate.markEnd(parseWhileStatement(), startToken);
                case "with":
                  return delegate.markEnd(parseWithStatement(), startToken);
              }
            }
            expr = parseExpression();
            if (expr.type === Syntax.Identifier && match(":")) {
              lex();
              key = "$" + expr.name;
              if (Object.prototype.hasOwnProperty.call(state.labelSet, key)) {
                throwError({}, Messages.Redeclaration, "Label", expr.name);
              }
              state.labelSet[key] = true;
              labeledBody = parseStatement();
              delete state.labelSet[key];
              return delegate.markEnd(delegate.createLabeledStatement(expr, labeledBody), startToken);
            }
            consumeSemicolon();
            return delegate.markEnd(delegate.createExpressionStatement(expr), startToken);
          }
          function parseFunctionSourceElements() {
            var sourceElement, sourceElements = [], token, directive, firstRestricted, oldLabelSet, oldInIteration, oldInSwitch, oldInFunctionBody, startToken;
            startToken = lookahead;
            expect("{");
            while (index < length) {
              if (lookahead.type !== Token.StringLiteral) {
                break;
              }
              token = lookahead;
              sourceElement = parseSourceElement();
              sourceElements.push(sourceElement);
              if (sourceElement.expression.type !== Syntax.Literal) {
                break;
              }
              directive = source.slice(token.start + 1, token.end - 1);
              if (directive === "use strict") {
                strict = true;
                if (firstRestricted) {
                  throwErrorTolerant(firstRestricted, Messages.StrictOctalLiteral);
                }
              } else {
                if (!firstRestricted && token.octal) {
                  firstRestricted = token;
                }
              }
            }
            oldLabelSet = state.labelSet;
            oldInIteration = state.inIteration;
            oldInSwitch = state.inSwitch;
            oldInFunctionBody = state.inFunctionBody;
            state.labelSet = {};
            state.inIteration = false;
            state.inSwitch = false;
            state.inFunctionBody = true;
            while (index < length) {
              if (match("}")) {
                break;
              }
              sourceElement = parseSourceElement();
              if (typeof sourceElement === "undefined") {
                break;
              }
              sourceElements.push(sourceElement);
            }
            expect("}");
            state.labelSet = oldLabelSet;
            state.inIteration = oldInIteration;
            state.inSwitch = oldInSwitch;
            state.inFunctionBody = oldInFunctionBody;
            return delegate.markEnd(delegate.createBlockStatement(sourceElements), startToken);
          }
          function parseParams(firstRestricted) {
            var param, params = [], token, stricted, paramSet, key, message;
            expect("(");
            if (!match(")")) {
              paramSet = {};
              while (index < length) {
                token = lookahead;
                param = parseVariableIdentifier();
                key = "$" + token.value;
                if (strict) {
                  if (isRestrictedWord(token.value)) {
                    stricted = token;
                    message = Messages.StrictParamName;
                  }
                  if (Object.prototype.hasOwnProperty.call(paramSet, key)) {
                    stricted = token;
                    message = Messages.StrictParamDupe;
                  }
                } else if (!firstRestricted) {
                  if (isRestrictedWord(token.value)) {
                    firstRestricted = token;
                    message = Messages.StrictParamName;
                  } else if (isStrictModeReservedWord(token.value)) {
                    firstRestricted = token;
                    message = Messages.StrictReservedWord;
                  } else if (Object.prototype.hasOwnProperty.call(paramSet, key)) {
                    firstRestricted = token;
                    message = Messages.StrictParamDupe;
                  }
                }
                params.push(param);
                paramSet[key] = true;
                if (match(")")) {
                  break;
                }
                expect(",");
              }
            }
            expect(")");
            return {
              params,
              stricted,
              firstRestricted,
              message
            };
          }
          function parseFunctionDeclaration() {
            var id, params = [], body, token, stricted, tmp, firstRestricted, message, previousStrict, startToken;
            startToken = lookahead;
            expectKeyword("function");
            token = lookahead;
            id = parseVariableIdentifier();
            if (strict) {
              if (isRestrictedWord(token.value)) {
                throwErrorTolerant(token, Messages.StrictFunctionName);
              }
            } else {
              if (isRestrictedWord(token.value)) {
                firstRestricted = token;
                message = Messages.StrictFunctionName;
              } else if (isStrictModeReservedWord(token.value)) {
                firstRestricted = token;
                message = Messages.StrictReservedWord;
              }
            }
            tmp = parseParams(firstRestricted);
            params = tmp.params;
            stricted = tmp.stricted;
            firstRestricted = tmp.firstRestricted;
            if (tmp.message) {
              message = tmp.message;
            }
            previousStrict = strict;
            body = parseFunctionSourceElements();
            if (strict && firstRestricted) {
              throwError(firstRestricted, message);
            }
            if (strict && stricted) {
              throwErrorTolerant(stricted, message);
            }
            strict = previousStrict;
            return delegate.markEnd(delegate.createFunctionDeclaration(id, params, [], body), startToken);
          }
          function parseFunctionExpression() {
            var token, id = null, stricted, firstRestricted, message, tmp, params = [], body, previousStrict, startToken;
            startToken = lookahead;
            expectKeyword("function");
            if (!match("(")) {
              token = lookahead;
              id = parseVariableIdentifier();
              if (strict) {
                if (isRestrictedWord(token.value)) {
                  throwErrorTolerant(token, Messages.StrictFunctionName);
                }
              } else {
                if (isRestrictedWord(token.value)) {
                  firstRestricted = token;
                  message = Messages.StrictFunctionName;
                } else if (isStrictModeReservedWord(token.value)) {
                  firstRestricted = token;
                  message = Messages.StrictReservedWord;
                }
              }
            }
            tmp = parseParams(firstRestricted);
            params = tmp.params;
            stricted = tmp.stricted;
            firstRestricted = tmp.firstRestricted;
            if (tmp.message) {
              message = tmp.message;
            }
            previousStrict = strict;
            body = parseFunctionSourceElements();
            if (strict && firstRestricted) {
              throwError(firstRestricted, message);
            }
            if (strict && stricted) {
              throwErrorTolerant(stricted, message);
            }
            strict = previousStrict;
            return delegate.markEnd(delegate.createFunctionExpression(id, params, [], body), startToken);
          }
          function parseSourceElement() {
            if (lookahead.type === Token.Keyword) {
              switch (lookahead.value) {
                case "const":
                case "let":
                  return parseConstLetDeclaration(lookahead.value);
                case "function":
                  return parseFunctionDeclaration();
                default:
                  return parseStatement();
              }
            }
            if (lookahead.type !== Token.EOF) {
              return parseStatement();
            }
          }
          function parseSourceElements() {
            var sourceElement, sourceElements = [], token, directive, firstRestricted;
            while (index < length) {
              token = lookahead;
              if (token.type !== Token.StringLiteral) {
                break;
              }
              sourceElement = parseSourceElement();
              sourceElements.push(sourceElement);
              if (sourceElement.expression.type !== Syntax.Literal) {
                break;
              }
              directive = source.slice(token.start + 1, token.end - 1);
              if (directive === "use strict") {
                strict = true;
                if (firstRestricted) {
                  throwErrorTolerant(firstRestricted, Messages.StrictOctalLiteral);
                }
              } else {
                if (!firstRestricted && token.octal) {
                  firstRestricted = token;
                }
              }
            }
            while (index < length) {
              sourceElement = parseSourceElement();
              if (typeof sourceElement === "undefined") {
                break;
              }
              sourceElements.push(sourceElement);
            }
            return sourceElements;
          }
          function parseProgram() {
            var body, startToken;
            skipComment();
            peek();
            startToken = lookahead;
            strict = false;
            body = parseSourceElements();
            return delegate.markEnd(delegate.createProgram(body), startToken);
          }
          function filterTokenLocation() {
            var i, entry, token, tokens = [];
            for (i = 0; i < extra.tokens.length; ++i) {
              entry = extra.tokens[i];
              token = {
                type: entry.type,
                value: entry.value
              };
              if (extra.range) {
                token.range = entry.range;
              }
              if (extra.loc) {
                token.loc = entry.loc;
              }
              tokens.push(token);
            }
            extra.tokens = tokens;
          }
          function tokenize(code, options) {
            var toString, token, tokens;
            toString = String;
            if (typeof code !== "string" && !(code instanceof String)) {
              code = toString(code);
            }
            delegate = SyntaxTreeDelegate;
            source = code;
            index = 0;
            lineNumber = source.length > 0 ? 1 : 0;
            lineStart = 0;
            length = source.length;
            lookahead = null;
            state = {
              allowIn: true,
              labelSet: {},
              inFunctionBody: false,
              inIteration: false,
              inSwitch: false,
              lastCommentStart: -1
            };
            extra = {};
            options = options || {};
            options.tokens = true;
            extra.tokens = [];
            extra.tokenize = true;
            extra.openParenToken = -1;
            extra.openCurlyToken = -1;
            extra.range = typeof options.range === "boolean" && options.range;
            extra.loc = typeof options.loc === "boolean" && options.loc;
            if (typeof options.comment === "boolean" && options.comment) {
              extra.comments = [];
            }
            if (typeof options.tolerant === "boolean" && options.tolerant) {
              extra.errors = [];
            }
            try {
              peek();
              if (lookahead.type === Token.EOF) {
                return extra.tokens;
              }
              token = lex();
              while (lookahead.type !== Token.EOF) {
                try {
                  token = lex();
                } catch (lexError) {
                  token = lookahead;
                  if (extra.errors) {
                    extra.errors.push(lexError);
                    break;
                  } else {
                    throw lexError;
                  }
                }
              }
              filterTokenLocation();
              tokens = extra.tokens;
              if (typeof extra.comments !== "undefined") {
                tokens.comments = extra.comments;
              }
              if (typeof extra.errors !== "undefined") {
                tokens.errors = extra.errors;
              }
            } catch (e) {
              throw e;
            } finally {
              extra = {};
            }
            return tokens;
          }
          function parse(code, options) {
            var program, toString;
            toString = String;
            if (typeof code !== "string" && !(code instanceof String)) {
              code = toString(code);
            }
            delegate = SyntaxTreeDelegate;
            source = code;
            index = 0;
            lineNumber = source.length > 0 ? 1 : 0;
            lineStart = 0;
            length = source.length;
            lookahead = null;
            state = {
              allowIn: true,
              labelSet: {},
              inFunctionBody: false,
              inIteration: false,
              inSwitch: false,
              lastCommentStart: -1
            };
            extra = {};
            if (typeof options !== "undefined") {
              extra.range = typeof options.range === "boolean" && options.range;
              extra.loc = typeof options.loc === "boolean" && options.loc;
              extra.attachComment = typeof options.attachComment === "boolean" && options.attachComment;
              if (extra.loc && options.source !== null && options.source !== void 0) {
                extra.source = toString(options.source);
              }
              if (typeof options.tokens === "boolean" && options.tokens) {
                extra.tokens = [];
              }
              if (typeof options.comment === "boolean" && options.comment) {
                extra.comments = [];
              }
              if (typeof options.tolerant === "boolean" && options.tolerant) {
                extra.errors = [];
              }
              if (extra.attachComment) {
                extra.range = true;
                extra.comments = [];
                extra.bottomRightStack = [];
                extra.trailingComments = [];
                extra.leadingComments = [];
              }
            }
            try {
              program = parseProgram();
              if (typeof extra.comments !== "undefined") {
                program.comments = extra.comments;
              }
              if (typeof extra.tokens !== "undefined") {
                filterTokenLocation();
                program.tokens = extra.tokens;
              }
              if (typeof extra.errors !== "undefined") {
                program.errors = extra.errors;
              }
            } catch (e) {
              throw e;
            } finally {
              extra = {};
            }
            return program;
          }
          exports4.version = "1.2.2";
          exports4.tokenize = tokenize;
          exports4.parse = parse;
          exports4.Syntax = (function() {
            var name, types = {};
            if (typeof Object.create === "function") {
              types = /* @__PURE__ */ Object.create(null);
            }
            for (name in Syntax) {
              if (Syntax.hasOwnProperty(name)) {
                types[name] = Syntax[name];
              }
            }
            if (typeof Object.freeze === "function") {
              Object.freeze(types);
            }
            return types;
          })();
        });
      }, {}], 1: [function(require2, module3, exports3) {
        (function(process) {
          var parser = (function() {
            var parser2 = {
              trace: function trace() {
              },
              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 anonymous(yytext, yyleng, yylineno, yy, yystate, $$, _$) {
                if (!yy.ast) {
                  yy.ast = _ast;
                  _ast.initialize();
                }
                var $0 = $$.length - 1;
                switch (yystate) {
                  case 1:
                    yy.ast.set({ expression: { type: "root", value: $$[$0] } });
                    yy.ast.unshift();
                    return yy.ast.yield();
                  case 2:
                    yy.ast.set({ expression: { type: "root", value: $$[$0 - 1] } });
                    yy.ast.unshift();
                    return yy.ast.yield();
                  case 3:
                    yy.ast.unshift();
                    return yy.ast.yield();
                  case 4:
                    yy.ast.set({ operation: "member", scope: "child", expression: { type: "identifier", value: $$[$0 - 1] } });
                    yy.ast.unshift();
                    return yy.ast.yield();
                  case 5:
                    break;
                  case 6:
                    break;
                  case 7:
                    yy.ast.set({ operation: "member" });
                    yy.ast.push();
                    break;
                  case 8:
                    yy.ast.set({ operation: "subscript" });
                    yy.ast.push();
                    break;
                  case 9:
                    yy.ast.set({ scope: "child" });
                    break;
                  case 10:
                    yy.ast.set({ scope: "descendant" });
                    break;
                  case 11:
                    break;
                  case 12:
                    yy.ast.set({ scope: "child", operation: "member" });
                    break;
                  case 13:
                    break;
                  case 14:
                    yy.ast.set({ expression: { type: "wildcard", value: $$[$0] } });
                    break;
                  case 15:
                    yy.ast.set({ expression: { type: "identifier", value: $$[$0] } });
                    break;
                  case 16:
                    yy.ast.set({ expression: { type: "script_expression", value: $$[$0] } });
                    break;
                  case 17:
                    yy.ast.set({ expression: { type: "numeric_literal", value: parseInt($$[$0]) } });
                    break;
                  case 18:
                    break;
                  case 19:
                    yy.ast.set({ scope: "child" });
                    break;
                  case 20:
                    yy.ast.set({ scope: "descendant" });
                    break;
                  case 21:
                    break;
                  case 22:
                    break;
                  case 23:
                    break;
                  case 24:
                    $$[$0].length > 1 ? yy.ast.set({ expression: { type: "union", value: $$[$0] } }) : this.$ = $$[$0];
                    break;
                  case 25:
                    this.$ = [$$[$0]];
                    break;
                  case 26:
                    this.$ = $$[$0 - 2].concat($$[$0]);
                    break;
                  case 27:
                    this.$ = { expression: { type: "numeric_literal", value: parseInt($$[$0]) } };
                    yy.ast.set(this.$);
                    break;
                  case 28:
                    this.$ = { expression: { type: "string_literal", value: $$[$0] } };
                    yy.ast.set(this.$);
                    break;
                  case 29:
                    this.$ = { expression: { type: "slice", value: $$[$0] } };
                    yy.ast.set(this.$);
                    break;
                  case 30:
                    this.$ = { expression: { type: "wildcard", value: $$[$0] } };
                    yy.ast.set(this.$);
                    break;
                  case 31:
                    this.$ = { expression: { type: "script_expression", value: $$[$0] } };
                    yy.ast.set(this.$);
                    break;
                  case 32:
                    this.$ = { expression: { type: "filter_expression", value: $$[$0] } };
                    yy.ast.set(this.$);
                    break;
                  case 33:
                    this.$ = $$[$0];
                    break;
                  case 34:
                    this.$ = $$[$0];
                    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 parseError(str, hash) {
                if (hash.recoverable) {
                  this.trace(str);
                } else {
                  throw new Error(str);
                }
              },
              parse: function parse(input) {
                var self2 = this, stack = [0], vstack = [null], lstack = [], table = this.table, yytext = "", yylineno = 0, yyleng = 0, TERROR = 2, EOF = 1;
                var args = lstack.slice.call(arguments, 1);
                this.lexer.setInput(input);
                this.lexer.yy = this.yy;
                this.yy.lexer = this.lexer;
                this.yy.parser = this;
                if (typeof this.lexer.yylloc == "undefined") {
                  this.lexer.yylloc = {};
                }
                var yyloc = this.lexer.yylloc;
                lstack.push(yyloc);
                var ranges = this.lexer.options && this.lexer.options.ranges;
                if (typeof this.yy.parseError === "function") {
                  this.parseError = this.yy.parseError;
                } else {
                  this.parseError = Object.getPrototypeOf(this).parseError;
                }
                function lex() {
                  var token;
                  token = self2.lexer.lex() || EOF;
                  if (typeof token !== "number") {
                    token = self2.symbols_[token] || token;
                  }
                  return token;
                }
                var symbol, state, action, r, yyval = {}, p, len, newState, expected;
                while (true) {
                  state = stack[stack.length - 1];
                  if (this.defaultActions[state]) {
                    action = this.defaultActions[state];
                  } else {
                    if (symbol === null || typeof symbol == "undefined") {
                      symbol = lex();
                    }
                    action = table[state] && table[state][symbol];
                  }
                  if (typeof action === "undefined" || !action.length || !action[0]) {
                    var errStr = "";
                    expected = [];
                    for (p in table[state]) {
                      if (this.terminals_[p] && p > TERROR) {
                        expected.push("'" + this.terminals_[p] + "'");
                      }
                    }
                    if (this.lexer.showPosition) {
                      errStr = "Parse error on line " + (yylineno + 1) + ":\n" + this.lexer.showPosition() + "\nExpecting " + expected.join(", ") + ", got '" + (this.terminals_[symbol] || symbol) + "'";
                    } else {
                      errStr = "Parse error on line " + (yylineno + 1) + ": Unexpected " + (symbol == EOF ? "end of input" : "'" + (this.terminals_[symbol] || symbol) + "'");
                    }
                    this.parseError(errStr, {
                      text: this.lexer.match,
                      token: this.terminals_[symbol] || symbol,
                      line: this.lexer.yylineno,
                      loc: yyloc,
                      expected
                    });
                  }
                  if (action[0] instanceof Array && action.length > 1) {
                    throw new Error("Parse Error: multiple actions possible at state: " + state + ", token: " + symbol);
                  }
                  switch (action[0]) {
                    case 1:
                      stack.push(symbol);
                      vstack.push(this.lexer.yytext);
                      lstack.push(this.lexer.yylloc);
                      stack.push(action[1]);
                      symbol = null;
                      {
                        yyleng = this.lexer.yyleng;
                        yytext = this.lexer.yytext;
                        yylineno = this.lexer.yylineno;
                        yyloc = this.lexer.yylloc;
                      }
                      break;
                    case 2:
                      len = this.productions_[action[1]][1];
                      yyval.$ = vstack[vstack.length - len];
                      yyval._$ = {
                        first_line: lstack[lstack.length - (len || 1)].first_line,
                        last_line: lstack[lstack.length - 1].last_line,
                        first_column: lstack[lstack.length - (len || 1)].first_column,
                        last_column: lstack[lstack.length - 1].last_column
                      };
                      if (ranges) {
                        yyval._$.range = [
                          lstack[lstack.length - (len || 1)].range[0],
                          lstack[lstack.length - 1].range[1]
                        ];
                      }
                      r = this.performAction.apply(yyval, [
                        yytext,
                        yyleng,
                        yylineno,
                        this.yy,
                        action[1],
                        vstack,
                        lstack
                      ].concat(args));
                      if (typeof r !== "undefined") {
                        return r;
                      }
                      if (len) {
                        stack = stack.slice(0, -1 * len * 2);
                        vstack = vstack.slice(0, -1 * len);
                        lstack = lstack.slice(0, -1 * len);
                      }
                      stack.push(this.productions_[action[1]][0]);
                      vstack.push(yyval.$);
                      lstack.push(yyval._$);
                      newState = table[stack[stack.length - 2]][stack[stack.length - 1]];
                      stack.push(newState);
                      break;
                    case 3:
                      return true;
                  }
                }
                return true;
              }
            };
            var _ast = {
              initialize: function() {
                this._nodes = [];
                this._node = {};
                this._stash = [];
              },
              set: function(props) {
                for (var k in props) this._node[k] = props[k];
                return this._node;
              },
              node: function(obj) {
                if (arguments.length) this._node = obj;
                return this._node;
              },
              push: function() {
                this._nodes.push(this._node);
                this._node = {};
              },
              unshift: function() {
                this._nodes.unshift(this._node);
                this._node = {};
              },
              yield: function() {
                var _nodes = this._nodes;
                this.initialize();
                return _nodes;
              }
            };
            var lexer = /* @__PURE__ */ (function() {
              var lexer2 = {
                EOF: 1,
                parseError: function parseError(str, hash) {
                  if (this.yy.parser) {
                    this.yy.parser.parseError(str, hash);
                  } else {
                    throw new Error(str);
                  }
                },
                // resets the lexer, sets new input
                setInput: function(input) {
                  this._input = input;
                  this._more = this._backtrack = this.done = false;
                  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
                  };
                  if (this.options.ranges) {
                    this.yylloc.range = [0, 0];
                  }
                  this.offset = 0;
                  return this;
                },
                // consumes and returns one char from the input
                input: function() {
                  var ch = this._input[0];
                  this.yytext += ch;
                  this.yyleng++;
                  this.offset++;
                  this.match += ch;
                  this.matched += ch;
                  var lines = ch.match(/(?:\r\n?|\n).*/g);
                  if (lines) {
                    this.yylineno++;
                    this.yylloc.last_line++;
                  } else {
                    this.yylloc.last_column++;
                  }
                  if (this.options.ranges) {
                    this.yylloc.range[1]++;
                  }
                  this._input = this._input.slice(1);
                  return ch;
                },
                // unshifts one char (or a string) into the input
                unput: function(ch) {
                  var len = ch.length;
                  var lines = ch.split(/(?:\r\n?|\n)/g);
                  this._input = ch + this._input;
                  this.yytext = this.yytext.substr(0, this.yytext.length - len - 1);
                  this.offset -= len;
                  var oldLines = 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);
                  if (lines.length - 1) {
                    this.yylineno -= lines.length - 1;
                  }
                  var r = this.yylloc.range;
                  this.yylloc = {
                    first_line: this.yylloc.first_line,
                    last_line: this.yylineno + 1,
                    first_column: this.yylloc.first_column,
                    last_column: lines ? (lines.length === oldLines.length ? this.yylloc.first_column : 0) + oldLines[oldLines.length - lines.length].length - lines[0].length : this.yylloc.first_column - len
                  };
                  if (this.options.ranges) {
                    this.yylloc.range = [r[0], r[0] + this.yyleng - len];
                  }
                  this.yyleng = this.yytext.length;
                  return this;
                },
                // When called from action, caches matched text and appends it on next action
                more: function() {
                  this._more = true;
                  return 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 = true;
                  } 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).\n" + this.showPosition(), {
                      text: "",
                      token: null,
                      line: this.yylineno
                    });
                  }
                  return this;
                },
                // retain first n characters of the match
                less: function(n) {
                  this.unput(this.match.slice(n));
                },
                // displays already matched input, i.e. for error messages
                pastInput: function() {
                  var past = this.matched.substr(0, this.matched.length - this.match.length);
                  return (past.length > 20 ? "..." : "") + past.substr(-20).replace(/\n/g, "");
                },
                // displays upcoming input, i.e. for error messages
                upcomingInput: function() {
                  var next = this.match;
                  if (next.length < 20) {
                    next += this._input.substr(0, 20 - next.length);
                  }
                  return (next.substr(0, 20) + (next.length > 20 ? "..." : "")).replace(/\n/g, "");
                },
                // displays the character position where the lexing error occurred, i.e. for error messages
                showPosition: function() {
                  var pre = this.pastInput();
                  var c = new Array(pre.length + 1).join("-");
                  return pre + this.upcomingInput() + "\n" + c + "^";
                },
                // test the lexed token: return FALSE when not a match, otherwise return token
                test_match: function(match, indexed_rule) {
                  var token, lines, backup;
                  if (this.options.backtrack_lexer) {
                    backup = {
                      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
                    };
                    if (this.options.ranges) {
                      backup.yylloc.range = this.yylloc.range.slice(0);
                    }
                  }
                  lines = match[0].match(/(?:\r\n?|\n).*/g);
                  if (lines) {
                    this.yylineno += lines.length;
                  }
                  this.yylloc = {
                    first_line: this.yylloc.last_line,
                    last_line: this.yylineno + 1,
                    first_column: this.yylloc.last_column,
                    last_column: lines ? lines[lines.length - 1].length - lines[lines.length - 1].match(/\r?\n?/)[0].length : this.yylloc.last_column + match[0].length
                  };
                  this.yytext += match[0];
                  this.match += match[0];
                  this.matches = match;
                  this.yyleng = this.yytext.length;
                  if (this.options.ranges) {
                    this.yylloc.range = [this.offset, this.offset += this.yyleng];
                  }
                  this._more = false;
                  this._backtrack = false;
                  this._input = this._input.slice(match[0].length);
                  this.matched += match[0];
                  token = this.performAction.call(this, this.yy, this, indexed_rule, this.conditionStack[this.conditionStack.length - 1]);
                  if (this.done && this._input) {
                    this.done = false;
                  }
                  if (token) {
                    return token;
                  } else if (this._backtrack) {
                    for (var k in backup) {
                      this[k] = backup[k];
                    }
                    return false;
                  }
                  return false;
                },
                // return next match in input
                next: function() {
                  if (this.done) {
                    return this.EOF;
                  }
                  if (!this._input) {
                    this.done = true;
                  }
                  var token, match, tempMatch, index;
                  if (!this._more) {
                    this.yytext = "";
                    this.match = "";
                  }
                  var rules = this._currentRules();
                  for (var i = 0; i < rules.length; i++) {
                    tempMatch = this._input.match(this.rules[rules[i]]);
                    if (tempMatch && (!match || tempMatch[0].length > match[0].length)) {
                      match = tempMatch;
                      index = i;
                      if (this.options.backtrack_lexer) {
                        token = this.test_match(tempMatch, rules[i]);
                        if (token !== false) {
                          return token;
                        } else if (this._backtrack) {
                          match = false;
                          continue;
                        } else {
                          return false;
                        }
                      } else if (!this.options.flex) {
                        break;
                      }
                    }
                  }
                  if (match) {
                    token = this.test_match(match, rules[index]);
                    if (token !== false) {
                      return token;
                    }
                    return false;
                  }
                  if (this._input === "") {
                    return this.EOF;
                  } else {
                    return this.parseError("Lexical error on line " + (this.yylineno + 1) + ". Unrecognized text.\n" + this.showPosition(), {
                      text: "",
                      token: null,
                      line: this.yylineno
                    });
                  }
                },
                // return next match that has a token
                lex: function lex() {
                  var r = this.next();
                  if (r) {
                    return r;
                  } else {
                    return this.lex();
                  }
                },
                // activates a new lexer condition state (pushes the new lexer condition state onto the condition stack)
                begin: function begin(condition) {
                  this.conditionStack.push(condition);
                },
                // pop the previously active lexer condition state off the condition stack
                popState: function popState() {
                  var n = this.conditionStack.length - 1;
                  if (n > 0) {
                    return this.conditionStack.pop();
                  } else {
                    return this.conditionStack[0];
                  }
                },
                // produce the lexer rule set which is active for the currently active lexer condition state
                _currentRules: function _currentRules() {
                  if (this.conditionStack.length && this.conditionStack[this.conditionStack.length - 1]) {
                    return this.conditions[this.conditionStack[this.conditionStack.length - 1]].rules;
                  } else {
                    return 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 topState(n) {
                  n = this.conditionStack.length - 1 - Math.abs(n || 0);
                  if (n >= 0) {
                    return this.conditionStack[n];
                  } else {
                    return "INITIAL";
                  }
                },
                // alias for begin(condition)
                pushState: function pushState(condition) {
                  this.begin(condition);
                },
                // return the number of states currently on the stack
                stateStackSize: function stateStackSize() {
                  return this.conditionStack.length;
                },
                options: {},
                performAction: function anonymous(yy, yy_, $avoiding_name_collisions, YY_START) {
                  switch ($avoiding_name_collisions) {
                    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:
                      yy_.yytext = yy_.yytext.substr(1, yy_.yyleng - 2);
                      return 32;
                    case 11:
                      yy_.yytext = yy_.yytext.substr(1, yy_.yyleng - 2);
                      return 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": true } }
              };
              return lexer2;
            })();
            parser2.lexer = lexer;
            function Parser() {
              this.yy = {};
            }
            Parser.prototype = parser2;
            parser2.Parser = Parser;
            return new Parser();
          })();
          if (typeof require2 !== "undefined" && typeof exports3 !== "undefined") {
            exports3.parser = parser;
            exports3.Parser = parser.Parser;
            exports3.parse = function() {
              return parser.parse.apply(parser, arguments);
            };
            exports3.main = function commonjsMain(args) {
              if (!args[1]) {
                console.log("Usage: " + args[0] + " FILE");
                process.exit(1);
              }
              var source = require2("fs").readFileSync(require2("path").normalize(args[1]), "utf8");
              return exports3.parser.parse(source);
            };
            if (typeof module3 !== "undefined" && require2.main === module3) {
              exports3.main(process.argv.slice(1));
            }
          }
        }).call(this, require2("_process"));
      }, { "_process": 14, "fs": 12, "path": 13 }], 2: [function(require2, module3, exports3) {
        module3.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(require2, module3, exports3) {
        var dict = require2("./dict");
        var fs = require2("fs");
        var grammar = {
          lex: {
            macros: {
              esc: "\\\\",
              int: dict.integer
            },
            rules: [
              ["\\$", "return 'DOLLAR'"],
              ["\\.\\.", "return 'DOT_DOT'"],
              ["\\.", "return 'DOT'"],
              ["\\*", "return 'STAR'"],
              [dict.identifier, "return 'IDENTIFIER'"],
              ["\\[", "return '['"],
              ["\\]", "return ']'"],
              [",", "return ','"],
              ["({int})?\\:({int})?(\\:({int})?)?", "return 'ARRAY_SLICE'"],
              ["{int}", "return 'INTEGER'"],
              [dict.qq_string, "yytext = yytext.substr(1,yyleng-2); return 'QQ_STRING';"],
              [dict.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"]
            ]
          }
        };
        if (fs.readFileSync) {
          grammar.moduleInclude = fs.readFileSync(require2.resolve("../include/module.js"));
          grammar.actionInclude = fs.readFileSync(require2.resolve("../include/action.js"));
        }
        module3.exports = grammar;
      }, { "./dict": 2, "fs": 12 }], 4: [function(require2, module3, exports3) {
        var aesprim = require2("./aesprim");
        var slice = require2("./slice");
        var _evaluate = require2("static-eval");
        var _uniq = require2("underscore").uniq;
        var Handlers = function() {
          return this.initialize.apply(this, arguments);
        };
        Handlers.prototype.initialize = function() {
          this.traverse = traverser(true);
          this.descend = traverser();
        };
        Handlers.prototype.keys = Object.keys;
        Handlers.prototype.resolve = function(component) {
          var key = [component.operation, component.scope, component.expression.type].join("-");
          var method = this._fns[key];
          if (!method) throw new Error("couldn't resolve key: " + key);
          return method.bind(this);
        };
        Handlers.prototype.register = function(key, handler) {
          if (!handler instanceof Function) {
            throw new Error("handler must be a function");
          }
          this._fns[key] = handler;
        };
        Handlers.prototype._fns = {
          "member-child-identifier": function(component, partial) {
            var key = component.expression.value;
            var value = partial.value;
            if (value instanceof Object && key in value) {
              return [{ value: value[key], path: partial.path.concat(key) }];
            }
          },
          "member-descendant-identifier": _traverse(function(key, value, ref2) {
            return key == ref2;
          }),
          "subscript-child-numeric_literal": _descend(function(key, value, ref2) {
            return key === ref2;
          }),
          "member-child-numeric_literal": _descend(function(key, value, ref2) {
            return String(key) === String(ref2);
          }),
          "subscript-descendant-numeric_literal": _traverse(function(key, value, ref2) {
            return key === ref2;
          }),
          "member-child-wildcard": _descend(function() {
            return true;
          }),
          "member-descendant-wildcard": _traverse(function() {
            return true;
          }),
          "subscript-descendant-wildcard": _traverse(function() {
            return true;
          }),
          "subscript-child-wildcard": _descend(function() {
            return true;
          }),
          "subscript-child-slice": function(component, partial) {
            if (is_array(partial.value)) {
              var args = component.expression.value.split(":").map(_parse_nullable_int);
              var values = partial.value.map(function(v, i) {
                return { value: v, path: partial.path.concat(i) };
              });
              return slice.apply(null, [values].concat(args));
            }
          },
          "subscript-child-union": function(component, partial) {
            var results = [];
            component.expression.value.forEach(function(component2) {
              var _component = { operation: "subscript", scope: "child", expression: component2.expression };
              var handler = this.resolve(_component);
              var _results = handler(_component, partial);
              if (_results) {
                results = results.concat(_results);
              }
            }, this);
            return unique(results);
          },
          "subscript-descendant-union": function(component, partial, count) {
            var jp2 = require2("..");
            var self2 = this;
            var results = [];
            var nodes = jp2.nodes(partial, "$..*").slice(1);
            nodes.forEach(function(node) {
              if (results.length >= count) return;
              component.expression.value.forEach(function(component2) {
                var _component = { operation: "subscript", scope: "child", expression: component2.expression };
                var handler = self2.resolve(_component);
                var _results = handler(_component, node);
                results = results.concat(_results);
              });
            });
            return unique(results);
          },
          "subscript-child-filter_expression": function(component, partial, count) {
            var src = component.expression.value.slice(2, -1);
            var ast = aesprim.parse(src).body[0].expression;
            var passable = function(key, value) {
              return evaluate(ast, { "@": value });
            };
            return this.descend(partial, null, passable, count);
          },
          "subscript-descendant-filter_expression": function(component, partial, count) {
            var src = component.expression.value.slice(2, -1);
            var ast = aesprim.parse(src).body[0].expression;
            var passable = function(key, value) {
              return evaluate(ast, { "@": value });
            };
            return this.traverse(partial, null, passable, count);
          },
          "subscript-child-script_expression": function(component, partial) {
            var exp = component.expression.value.slice(1, -1);
            return eval_recurse(partial, exp, "$[{{value}}]");
          },
          "member-child-script_expression": function(component, partial) {
            var exp = component.expression.value.slice(1, -1);
            return eval_recurse(partial, exp, "$.{{value}}");
          },
          "member-descendant-script_expression": function(component, partial) {
            var exp = component.expression.value.slice(1, -1);
            return eval_recurse(partial, exp, "$..value");
          }
        };
        Handlers.prototype._fns["subscript-child-string_literal"] = Handlers.prototype._fns["member-child-identifier"];
        Handlers.prototype._fns["member-descendant-numeric_literal"] = Handlers.prototype._fns["subscript-descendant-string_literal"] = Handlers.prototype._fns["member-descendant-identifier"];
        function eval_recurse(partial, src, template) {
          var jp2 = require2("./index");
          var ast = aesprim.parse(src).body[0].expression;
          var value = evaluate(ast, { "@": partial.value });
          var path = template.replace(/\{\{\s*value\s*\}\}/g, value);
          var results = jp2.nodes(partial.value, path);
          results.forEach(function(r) {
            r.path = partial.path.concat(r.path.slice(1));
          });
          return results;
        }
        function is_array(val) {
          return Array.isArray(val);
        }
        function is_object(val) {
          return val && !(val instanceof Array) && val instanceof Object;
        }
        function traverser(recurse) {
          return function(partial, ref2, passable, count) {
            var value = partial.value;
            var path = partial.path;
            var results = [];
            var descend = function(value2, path2) {
              if (is_array(value2)) {
                value2.forEach(function(element, index) {
                  if (results.length >= count) {
                    return;
                  }
                  if (passable(index, element, ref2)) {
                    results.push({ path: path2.concat(index), value: element });
                  }
                });
                value2.forEach(function(element, index) {
                  if (results.length >= count) {
                    return;
                  }
                  if (recurse) {
                    descend(element, path2.concat(index));
                  }
                });
              } else if (is_object(value2)) {
                this.keys(value2).forEach(function(k) {
                  if (results.length >= count) {
                    return;
                  }
                  if (passable(k, value2[k], ref2)) {
                    results.push({ path: path2.concat(k), value: value2[k] });
                  }
                });
                this.keys(value2).forEach(function(k) {
                  if (results.length >= count) {
                    return;
                  }
                  if (recurse) {
                    descend(value2[k], path2.concat(k));
                  }
                });
              }
            }.bind(this);
            descend(value, path);
            return results;
          };
        }
        function _descend(passable) {
          return function(component, partial, count) {
            return this.descend(partial, component.expression.value, passable, count);
          };
        }
        function _traverse(passable) {
          return function(component, partial, count) {
            return this.traverse(partial, component.expression.value, passable, count);
          };
        }
        function evaluate() {
          try {
            return _evaluate.apply(this, arguments);
          } catch (e) {
          }
        }
        function unique(results) {
          results = results.filter(function(d) {
            return d;
          });
          return _uniq(
            results,
            function(r) {
              return r.path.map(function(c) {
                return String(c).replace("-", "--");
              }).join("-");
            }
          );
        }
        function _parse_nullable_int(val) {
          var sval = String(val);
          return sval.match(/^-?[0-9]+$/) ? parseInt(sval) : null;
        }
        module3.exports = Handlers;
      }, { "..": "jsonpath", "./aesprim": "./aesprim", "./index": 5, "./slice": 7, "static-eval": 15, "underscore": 12 }], 5: [function(require2, module3, exports3) {
        var assert = require2("assert");
        var dict = require2("./dict");
        var Parser = require2("./parser");
        var Handlers = require2("./handlers");
        var JSONPath = function() {
          this.initialize.apply(this, arguments);
        };
        JSONPath.prototype.initialize = function() {
          this.parser = new Parser();
          this.handlers = new Handlers();
        };
        JSONPath.prototype.parse = function(string) {
          assert.ok(_is_string(string), "we need a path");
          return this.parser.parse(string);
        };
        JSONPath.prototype.parent = function(obj, string) {
          assert.ok(obj instanceof Object, "obj needs to be an object");
          assert.ok(string, "we need a path");
          var node = this.nodes(obj, string)[0];
          node.path.pop();
          return this.value(obj, node.path);
        };
        JSONPath.prototype.apply = function(obj, string, fn) {
          assert.ok(obj instanceof Object, "obj needs to be an object");
          assert.ok(string, "we need a path");
          assert.equal(typeof fn, "function", "fn needs to be function");
          var nodes = this.nodes(obj, string).sort(function(a, b) {
            return b.path.length - a.path.length;
          });
          nodes.forEach(function(node) {
            var key = node.path.pop();
            var parent = this.value(obj, this.stringify(node.path));
            var val = node.value = fn.call(obj, parent[key]);
            parent[key] = val;
          }, this);
          return nodes;
        };
        JSONPath.prototype.value = function(obj, path, value) {
          assert.ok(obj instanceof Object, "obj needs to be an object");
          assert.ok(path, "we need a path");
          if (arguments.length >= 3) {
            var node = this.nodes(obj, path).shift();
            if (!node) return this._vivify(obj, path, value);
            var key = node.path.slice(-1).shift();
            var parent = this.parent(obj, this.stringify(node.path));
            parent[key] = value;
          }
          return this.query(obj, this.stringify(path), 1).shift();
        };
        JSONPath.prototype._vivify = function(obj, string, value) {
          var self2 = this;
          assert.ok(obj instanceof Object, "obj needs to be an object");
          assert.ok(string, "we need a path");
          var path = this.parser.parse(string).map(function(component) {
            return component.expression.value;
          });
          var setValue = function(path2, value2) {
            var key = path2.pop();
            var node = self2.value(obj, path2);
            if (!node) {
              setValue(path2.concat(), typeof key === "string" ? {} : []);
              node = self2.value(obj, path2);
            }
            node[key] = value2;
          };
          setValue(path, value);
          return this.query(obj, string)[0];
        };
        JSONPath.prototype.query = function(obj, string, count) {
          assert.ok(obj instanceof Object, "obj needs to be an object");
          assert.ok(_is_string(string), "we need a path");
          var results = this.nodes(obj, string, count).map(function(r) {
            return r.value;
          });
          return results;
        };
        JSONPath.prototype.paths = function(obj, string, count) {
          assert.ok(obj instanceof Object, "obj needs to be an object");
          assert.ok(string, "we need a path");
          var results = this.nodes(obj, string, count).map(function(r) {
            return r.path;
          });
          return results;
        };
        JSONPath.prototype.nodes = function(obj, string, count) {
          assert.ok(obj instanceof Object, "obj needs to be an object");
          assert.ok(string, "we need a path");
          if (count === 0) return [];
          var path = this.parser.parse(string);
          var handlers = this.handlers;
          var partials = [{ path: ["$"], value: obj }];
          var matches = [];
          if (path.length && path[0].expression.type == "root") path.shift();
          if (!path.length) return partials;
          path.forEach(function(component, index) {
            if (matches.length >= count) return;
            var handler = handlers.resolve(component);
            var _partials = [];
            partials.forEach(function(p) {
              if (matches.length >= count) return;
              var results = handler(component, p, count);
              if (index == path.length - 1) {
                matches = matches.concat(results || []);
              } else {
                _partials = _partials.concat(results || []);
              }
            });
            partials = _partials;
          });
          return count ? matches.slice(0, count) : matches;
        };
        JSONPath.prototype.stringify = function(path) {
          assert.ok(path, "we need a path");
          var string = "$";
          var templates = {
            "descendant-member": "..{{value}}",
            "child-member": ".{{value}}",
            "descendant-subscript": "..[{{value}}]",
            "child-subscript": "[{{value}}]"
          };
          path = this._normalize(path);
          path.forEach(function(component) {
            if (component.expression.type == "root") return;
            var key = [component.scope, component.operation].join("-");
            var template = templates[key];
            var value;
            if (component.expression.type == "string_literal") {
              value = JSON.stringify(component.expression.value);
            } else {
              value = component.expression.value;
            }
            if (!template) throw new Error("couldn't find template " + key);
            string += template.replace(/{{value}}/, value);
          });
          return string;
        };
        JSONPath.prototype._normalize = function(path) {
          assert.ok(path, "we need a path");
          if (typeof path == "string") {
            return this.parser.parse(path);
          } else if (Array.isArray(path) && typeof path[0] == "string") {
            var _path = [{ expression: { type: "root", value: "$" } }];
            path.forEach(function(component, index) {
              if (component == "$" && index === 0) return;
              if (typeof component == "string" && component.match("^" + dict.identifier + "$")) {
                _path.push({
                  operation: "member",
                  scope: "child",
                  expression: { value: component, type: "identifier" }
                });
              } else {
                var type = typeof component == "number" ? "numeric_literal" : "string_literal";
                _path.push({
                  operation: "subscript",
                  scope: "child",
                  expression: { value: component, type }
                });
              }
            });
            return _path;
          } else if (Array.isArray(path) && typeof path[0] == "object") {
            return path;
          }
          throw new Error("couldn't understand path " + path);
        };
        function _is_string(obj) {
          return Object.prototype.toString.call(obj) == "[object String]";
        }
        JSONPath.Handlers = Handlers;
        JSONPath.Parser = Parser;
        var instance = new JSONPath();
        instance.JSONPath = JSONPath;
        module3.exports = instance;
      }, { "./dict": 2, "./handlers": 4, "./parser": 6, "assert": 8 }], 6: [function(require2, module3, exports3) {
        var grammar = require2("./grammar");
        var gparser = require2("../generated/parser");
        var Parser = function() {
          var parser = new gparser.Parser();
          var _parseError = parser.parseError;
          parser.yy.parseError = function() {
            if (parser.yy.ast) {
              parser.yy.ast.initialize();
            }
            _parseError.apply(parser, arguments);
          };
          return parser;
        };
        Parser.grammar = grammar;
        module3.exports = Parser;
      }, { "../generated/parser": 1, "./grammar": 3 }], 7: [function(require2, module3, exports3) {
        module3.exports = function(arr, start, end, step) {
          if (typeof start == "string") throw new Error("start cannot be a string");
          if (typeof end == "string") throw new Error("end cannot be a string");
          if (typeof step == "string") throw new Error("step cannot be a string");
          var len = arr.length;
          if (step === 0) throw new Error("step cannot be zero");
          step = step ? integer(step) : 1;
          start = start < 0 ? len + start : start;
          end = end < 0 ? len + end : end;
          start = integer(start === 0 ? 0 : !start ? step > 0 ? 0 : len - 1 : start);
          end = integer(end === 0 ? 0 : !end ? step > 0 ? len : -1 : end);
          start = step > 0 ? Math.max(0, start) : Math.min(len, start);
          end = step > 0 ? Math.min(end, len) : Math.max(-1, end);
          if (step > 0 && end <= start) return [];
          if (step < 0 && start <= end) return [];
          var result = [];
          for (var i = start; i != end; i += step) {
            if (step < 0 && i <= end || step > 0 && i >= end) break;
            result.push(arr[i]);
          }
          return result;
        };
        function integer(val) {
          return String(val).match(/^[0-9]+$/) ? parseInt(val) : Number.isFinite(val) ? parseInt(val, 10) : 0;
        }
      }, {}], 8: [function(require2, module3, exports3) {
        var util = require2("util/");
        var pSlice = Array.prototype.slice;
        var hasOwn = Object.prototype.hasOwnProperty;
        var assert = module3.exports = ok;
        assert.AssertionError = function AssertionError(options) {
          this.name = "AssertionError";
          this.actual = options.actual;
          this.expected = options.expected;
          this.operator = options.operator;
          if (options.message) {
            this.message = options.message;
            this.generatedMessage = false;
          } else {
            this.message = getMessage(this);
            this.generatedMessage = true;
          }
          var stackStartFunction = options.stackStartFunction || fail;
          if (Error.captureStackTrace) {
            Error.captureStackTrace(this, stackStartFunction);
          } else {
            var err = new Error();
            if (err.stack) {
              var out = err.stack;
              var fn_name = stackStartFunction.name;
              var idx = out.indexOf("\n" + fn_name);
              if (idx >= 0) {
                var next_line = out.indexOf("\n", idx + 1);
                out = out.substring(next_line + 1);
              }
              this.stack = out;
            }
          }
        };
        util.inherits(assert.AssertionError, Error);
        function replacer(key, value) {
          if (util.isUndefined(value)) {
            return "" + value;
          }
          if (util.isNumber(value) && !isFinite(value)) {
            return value.toString();
          }
          if (util.isFunction(value) || util.isRegExp(value)) {
            return value.toString();
          }
          return value;
        }
        function truncate(s, n) {
          if (util.isString(s)) {
            return s.length < n ? s : s.slice(0, n);
          } else {
            return s;
          }
        }
        function getMessage(self2) {
          return truncate(JSON.stringify(self2.actual, replacer), 128) + " " + self2.operator + " " + truncate(JSON.stringify(self2.expected, replacer), 128);
        }
        function fail(actual, expected, message, operator, stackStartFunction) {
          throw new assert.AssertionError({
            message,
            actual,
            expected,
            operator,
            stackStartFunction
          });
        }
        assert.fail = fail;
        function ok(value, message) {
          if (!value) fail(value, true, message, "==", assert.ok);
        }
        assert.ok = ok;
        assert.equal = function equal(actual, expected, message) {
          if (actual != expected) fail(actual, expected, message, "==", assert.equal);
        };
        assert.notEqual = function notEqual(actual, expected, message) {
          if (actual == expected) {
            fail(actual, expected, message, "!=", assert.notEqual);
          }
        };
        assert.deepEqual = function deepEqual(actual, expected, message) {
          if (!_deepEqual(actual, expected)) {
            fail(actual, expected, message, "deepEqual", assert.deepEqual);
          }
        };
        function _deepEqual(actual, expected) {
          if (actual === expected) {
            return true;
          } else if (util.isBuffer(actual) && util.isBuffer(expected)) {
            if (actual.length != expected.length) return false;
            for (var i = 0; i < actual.length; i++) {
              if (actual[i] !== expected[i]) return false;
            }
            return true;
          } else if (util.isDate(actual) && util.isDate(expected)) {
            return actual.getTime() === expected.getTime();
          } else if (util.isRegExp(actual) && util.isRegExp(expected)) {
            return actual.source === expected.source && actual.global === expected.global && actual.multiline === expected.multiline && actual.lastIndex === expected.lastIndex && actual.ignoreCase === expected.ignoreCase;
          } else if (!util.isObject(actual) && !util.isObject(expected)) {
            return actual == expected;
          } else {
            return objEquiv(actual, expected);
          }
        }
        function isArguments(object) {
          return Object.prototype.toString.call(object) == "[object Arguments]";
        }
        function objEquiv(a, b) {
          if (util.isNullOrUndefined(a) || util.isNullOrUndefined(b))
            return false;
          if (a.prototype !== b.prototype) return false;
          if (util.isPrimitive(a) || util.isPrimitive(b)) {
            return a === b;
          }
          var aIsArgs = isArguments(a), bIsArgs = isArguments(b);
          if (aIsArgs && !bIsArgs || !aIsArgs && bIsArgs)
            return false;
          if (aIsArgs) {
            a = pSlice.call(a);
            b = pSlice.call(b);
            return _deepEqual(a, b);
          }
          var ka = objectKeys(a), kb = objectKeys(b), key, i;
          if (ka.length != kb.length)
            return false;
          ka.sort();
          kb.sort();
          for (i = ka.length - 1; i >= 0; i--) {
            if (ka[i] != kb[i])
              return false;
          }
          for (i = ka.length - 1; i >= 0; i--) {
            key = ka[i];
            if (!_deepEqual(a[key], b[key])) return false;
          }
          return true;
        }
        assert.notDeepEqual = function notDeepEqual(actual, expected, message) {
          if (_deepEqual(actual, expected)) {
            fail(actual, expected, message, "notDeepEqual", assert.notDeepEqual);
          }
        };
        assert.strictEqual = function strictEqual(actual, expected, message) {
          if (actual !== expected) {
            fail(actual, expected, message, "===", assert.strictEqual);
          }
        };
        assert.notStrictEqual = function notStrictEqual(actual, expected, message) {
          if (actual === expected) {
            fail(actual, expected, message, "!==", assert.notStrictEqual);
          }
        };
        function expectedException(actual, expected) {
          if (!actual || !expected) {
            return false;
          }
          if (Object.prototype.toString.call(expected) == "[object RegExp]") {
            return expected.test(actual);
          } else if (actual instanceof expected) {
            return true;
          } else if (expected.call({}, actual) === true) {
            return true;
          }
          return false;
        }
        function _throws(shouldThrow, block, expected, message) {
          var actual;
          if (util.isString(expected)) {
            message = expected;
            expected = null;
          }
          try {
            block();
          } catch (e) {
            actual = e;
          }
          message = (expected && expected.name ? " (" + expected.name + ")." : ".") + (message ? " " + message : ".");
          if (shouldThrow && !actual) {
            fail(actual, expected, "Missing expected exception" + message);
          }
          if (!shouldThrow && expectedException(actual, expected)) {
            fail(actual, expected, "Got unwanted exception" + message);
          }
          if (shouldThrow && actual && expected && !expectedException(actual, expected) || !shouldThrow && actual) {
            throw actual;
          }
        }
        assert.throws = function(block, error, message) {
          _throws.apply(this, [true].concat(pSlice.call(arguments)));
        };
        assert.doesNotThrow = function(block, message) {
          _throws.apply(this, [false].concat(pSlice.call(arguments)));
        };
        assert.ifError = function(err) {
          if (err) {
            throw err;
          }
        };
        var objectKeys = Object.keys || function(obj) {
          var keys = [];
          for (var key in obj) {
            if (hasOwn.call(obj, key)) keys.push(key);
          }
          return keys;
        };
      }, { "util/": 11 }], 9: [function(require2, module3, exports3) {
        if (typeof Object.create === "function") {
          module3.exports = function inherits(ctor, superCtor) {
            ctor.super_ = superCtor;
            ctor.prototype = Object.create(superCtor.prototype, {
              constructor: {
                value: ctor,
                enumerable: false,
                writable: true,
                configurable: true
              }
            });
          };
        } else {
          module3.exports = function inherits(ctor, superCtor) {
            ctor.super_ = superCtor;
            var TempCtor = function() {
            };
            TempCtor.prototype = superCtor.prototype;
            ctor.prototype = new TempCtor();
            ctor.prototype.constructor = ctor;
          };
        }
      }, {}], 10: [function(require2, module3, exports3) {
        module3.exports = function isBuffer(arg) {
          return arg && typeof arg === "object" && typeof arg.copy === "function" && typeof arg.fill === "function" && typeof arg.readUInt8 === "function";
        };
      }, {}], 11: [function(require2, module3, exports3) {
        (function(process, global2) {
          var formatRegExp = /%[sdj%]/g;
          exports3.format = function(f) {
            if (!isString(f)) {
              var objects = [];
              for (var i = 0; i < arguments.length; i++) {
                objects.push(inspect(arguments[i]));
              }
              return objects.join(" ");
            }
            var i = 1;
            var args = arguments;
            var len = args.length;
            var str = String(f).replace(formatRegExp, function(x2) {
              if (x2 === "%%") return "%";
              if (i >= len) return x2;
              switch (x2) {
                case "%s":
                  return String(args[i++]);
                case "%d":
                  return Number(args[i++]);
                case "%j":
                  try {
                    return JSON.stringify(args[i++]);
                  } catch (_) {
                    return "[Circular]";
                  }
                default:
                  return x2;
              }
            });
            for (var x = args[i]; i < len; x = args[++i]) {
              if (isNull(x) || !isObject(x)) {
                str += " " + x;
              } else {
                str += " " + inspect(x);
              }
            }
            return str;
          };
          exports3.deprecate = function(fn, msg) {
            if (isUndefined(global2.process)) {
              return function() {
                return exports3.deprecate(fn, msg).apply(this, arguments);
              };
            }
            if (process.noDeprecation === true) {
              return fn;
            }
            var warned = false;
            function deprecated() {
              if (!warned) {
                if (process.throwDeprecation) {
                  throw new Error(msg);
                } else if (process.traceDeprecation) {
                  console.trace(msg);
                } else {
                  console.error(msg);
                }
                warned = true;
              }
              return fn.apply(this, arguments);
            }
            return deprecated;
          };
          var debugs = {};
          var debugEnviron;
          exports3.debuglog = function(set) {
            if (isUndefined(debugEnviron))
              debugEnviron = process.env.NODE_DEBUG || "";
            set = set.toUpperCase();
            if (!debugs[set]) {
              if (new RegExp("\\b" + set + "\\b", "i").test(debugEnviron)) {
                var pid = process.pid;
                debugs[set] = function() {
                  var msg = exports3.format.apply(exports3, arguments);
                  console.error("%s %d: %s", set, pid, msg);
                };
              } else {
                debugs[set] = function() {
                };
              }
            }
            return debugs[set];
          };
          function inspect(obj, opts) {
            var ctx = {
              seen: [],
              stylize: stylizeNoColor
            };
            if (arguments.length >= 3) ctx.depth = arguments[2];
            if (arguments.length >= 4) ctx.colors = arguments[3];
            if (isBoolean(opts)) {
              ctx.showHidden = opts;
            } else if (opts) {
              exports3._extend(ctx, opts);
            }
            if (isUndefined(ctx.showHidden)) ctx.showHidden = false;
            if (isUndefined(ctx.depth)) ctx.depth = 2;
            if (isUndefined(ctx.colors)) ctx.colors = false;
            if (isUndefined(ctx.customInspect)) ctx.customInspect = true;
            if (ctx.colors) ctx.stylize = stylizeWithColor;
            return formatValue(ctx, obj, ctx.depth);
          }
          exports3.inspect = inspect;
          inspect.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]
          };
          inspect.styles = {
            "special": "cyan",
            "number": "yellow",
            "boolean": "yellow",
            "undefined": "grey",
            "null": "bold",
            "string": "green",
            "date": "magenta",
            // "name": intentionally not styling
            "regexp": "red"
          };
          function stylizeWithColor(str, styleType) {
            var style = inspect.styles[styleType];
            if (style) {
              return "\x1B[" + inspect.colors[style][0] + "m" + str + "\x1B[" + inspect.colors[style][1] + "m";
            } else {
              return str;
            }
          }
          function stylizeNoColor(str, styleType) {
            return str;
          }
          function arrayToHash(array) {
            var hash = {};
            array.forEach(function(val, idx) {
              hash[val] = true;
            });
            return hash;
          }
          function formatValue(ctx, value, recurseTimes) {
            if (ctx.customInspect && value && isFunction(value.inspect) && // Filter out the util module, it's inspect function is special
            value.inspect !== exports3.inspect && // Also filter out any prototype objects using the circular check.
            !(value.constructor && value.constructor.prototype === value)) {
              var ret = value.inspect(recurseTimes, ctx);
              if (!isString(ret)) {
                ret = formatValue(ctx, ret, recurseTimes);
              }
              return ret;
            }
            var primitive = formatPrimitive(ctx, value);
            if (primitive) {
              return primitive;
            }
            var keys = Object.keys(value);
            var visibleKeys = arrayToHash(keys);
            if (ctx.showHidden) {
              keys = Object.getOwnPropertyNames(value);
            }
            if (isError(value) && (keys.indexOf("message") >= 0 || keys.indexOf("description") >= 0)) {
              return formatError(value);
            }
            if (keys.length === 0) {
              if (isFunction(value)) {
                var name = value.name ? ": " + value.name : "";
                return ctx.stylize("[Function" + name + "]", "special");
              }
              if (isRegExp(value)) {
                return ctx.stylize(RegExp.prototype.toString.call(value), "regexp");
              }
              if (isDate(value)) {
                return ctx.stylize(Date.prototype.toString.call(value), "date");
              }
              if (isError(value)) {
                return formatError(value);
              }
            }
            var base = "", array = false, braces = ["{", "}"];
            if (isArray(value)) {
              array = true;
              braces = ["[", "]"];
            }
            if (isFunction(value)) {
              var n = value.name ? ": " + value.name : "";
              base = " [Function" + n + "]";
            }
            if (isRegExp(value)) {
              base = " " + RegExp.prototype.toString.call(value);
            }
            if (isDate(value)) {
              base = " " + Date.prototype.toUTCString.call(value);
            }
            if (isError(value)) {
              base = " " + formatError(value);
            }
            if (keys.length === 0 && (!array || value.length == 0)) {
              return braces[0] + base + braces[1];
            }
            if (recurseTimes < 0) {
              if (isRegExp(value)) {
                return ctx.stylize(RegExp.prototype.toString.call(value), "regexp");
              } else {
                return ctx.stylize("[Object]", "special");
              }
            }
            ctx.seen.push(value);
            var output;
            if (array) {
              output = formatArray(ctx, value, recurseTimes, visibleKeys, keys);
            } else {
              output = keys.map(function(key) {
                return formatProperty(ctx, value, recurseTimes, visibleKeys, key, array);
              });
            }
            ctx.seen.pop();
            return reduceToSingleString(output, base, braces);
          }
          function formatPrimitive(ctx, value) {
            if (isUndefined(value))
              return ctx.stylize("undefined", "undefined");
            if (isString(value)) {
              var simple = "'" + JSON.stringify(value).replace(/^"|"$/g, "").replace(/'/g, "\\'").replace(/\\"/g, '"') + "'";
              return ctx.stylize(simple, "string");
            }
            if (isNumber(value))
              return ctx.stylize("" + value, "number");
            if (isBoolean(value))
              return ctx.stylize("" + value, "boolean");
            if (isNull(value))
              return ctx.stylize("null", "null");
          }
          function formatError(value) {
            return "[" + Error.prototype.toString.call(value) + "]";
          }
          function formatArray(ctx, value, recurseTimes, visibleKeys, keys) {
            var output = [];
            for (var i = 0, l = value.length; i < l; ++i) {
              if (hasOwnProperty(value, String(i))) {
                output.push(formatProperty(
                  ctx,
                  value,
                  recurseTimes,
                  visibleKeys,
                  String(i),
                  true
                ));
              } else {
                output.push("");
              }
            }
            keys.forEach(function(key) {
              if (!key.match(/^\d+$/)) {
                output.push(formatProperty(
                  ctx,
                  value,
                  recurseTimes,
                  visibleKeys,
                  key,
                  true
                ));
              }
            });
            return output;
          }
          function formatProperty(ctx, value, recurseTimes, visibleKeys, key, array) {
            var name, str, desc;
            desc = Object.getOwnPropertyDescriptor(value, key) || { value: value[key] };
            if (desc.get) {
              if (desc.set) {
                str = ctx.stylize("[Getter/Setter]", "special");
              } else {
                str = ctx.stylize("[Getter]", "special");
              }
            } else {
              if (desc.set) {
                str = ctx.stylize("[Setter]", "special");
              }
            }
            if (!hasOwnProperty(visibleKeys, key)) {
              name = "[" + key + "]";
            }
            if (!str) {
              if (ctx.seen.indexOf(desc.value) < 0) {
                if (isNull(recurseTimes)) {
                  str = formatValue(ctx, desc.value, null);
                } else {
                  str = formatValue(ctx, desc.value, recurseTimes - 1);
                }
                if (str.indexOf("\n") > -1) {
                  if (array) {
                    str = str.split("\n").map(function(line) {
                      return "  " + line;
                    }).join("\n").substr(2);
                  } else {
                    str = "\n" + str.split("\n").map(function(line) {
                      return "   " + line;
                    }).join("\n");
                  }
                }
              } else {
                str = ctx.stylize("[Circular]", "special");
              }
            }
            if (isUndefined(name)) {
              if (array && key.match(/^\d+$/)) {
                return str;
              }
              name = JSON.stringify("" + key);
              if (name.match(/^"([a-zA-Z_][a-zA-Z_0-9]*)"$/)) {
                name = name.substr(1, name.length - 2);
                name = ctx.stylize(name, "name");
              } else {
                name = name.replace(/'/g, "\\'").replace(/\\"/g, '"').replace(/(^"|"$)/g, "'");
                name = ctx.stylize(name, "string");
              }
            }
            return name + ": " + str;
          }
          function reduceToSingleString(output, base, braces) {
            var length = output.reduce(function(prev, cur) {
              if (cur.indexOf("\n") >= 0) ;
              return prev + cur.replace(/\u001b\[\d\d?m/g, "").length + 1;
            }, 0);
            if (length > 60) {
              return braces[0] + (base === "" ? "" : base + "\n ") + " " + output.join(",\n  ") + " " + braces[1];
            }
            return braces[0] + base + " " + output.join(", ") + " " + braces[1];
          }
          function isArray(ar) {
            return Array.isArray(ar);
          }
          exports3.isArray = isArray;
          function isBoolean(arg) {
            return typeof arg === "boolean";
          }
          exports3.isBoolean = isBoolean;
          function isNull(arg) {
            return arg === null;
          }
          exports3.isNull = isNull;
          function isNullOrUndefined(arg) {
            return arg == null;
          }
          exports3.isNullOrUndefined = isNullOrUndefined;
          function isNumber(arg) {
            return typeof arg === "number";
          }
          exports3.isNumber = isNumber;
          function isString(arg) {
            return typeof arg === "string";
          }
          exports3.isString = isString;
          function isSymbol(arg) {
            return typeof arg === "symbol";
          }
          exports3.isSymbol = isSymbol;
          function isUndefined(arg) {
            return arg === void 0;
          }
          exports3.isUndefined = isUndefined;
          function isRegExp(re) {
            return isObject(re) && objectToString(re) === "[object RegExp]";
          }
          exports3.isRegExp = isRegExp;
          function isObject(arg) {
            return typeof arg === "object" && arg !== null;
          }
          exports3.isObject = isObject;
          function isDate(d) {
            return isObject(d) && objectToString(d) === "[object Date]";
          }
          exports3.isDate = isDate;
          function isError(e) {
            return isObject(e) && (objectToString(e) === "[object Error]" || e instanceof Error);
          }
          exports3.isError = isError;
          function isFunction(arg) {
            return typeof arg === "function";
          }
          exports3.isFunction = isFunction;
          function isPrimitive(arg) {
            return arg === null || typeof arg === "boolean" || typeof arg === "number" || typeof arg === "string" || typeof arg === "symbol" || // ES6 symbol
            typeof arg === "undefined";
          }
          exports3.isPrimitive = isPrimitive;
          exports3.isBuffer = require2("./support/isBuffer");
          function objectToString(o) {
            return Object.prototype.toString.call(o);
          }
          function pad(n) {
            return n < 10 ? "0" + n.toString(10) : n.toString(10);
          }
          var months = [
            "Jan",
            "Feb",
            "Mar",
            "Apr",
            "May",
            "Jun",
            "Jul",
            "Aug",
            "Sep",
            "Oct",
            "Nov",
            "Dec"
          ];
          function timestamp() {
            var d = /* @__PURE__ */ new Date();
            var time = [
              pad(d.getHours()),
              pad(d.getMinutes()),
              pad(d.getSeconds())
            ].join(":");
            return [d.getDate(), months[d.getMonth()], time].join(" ");
          }
          exports3.log = function() {
            console.log("%s - %s", timestamp(), exports3.format.apply(exports3, arguments));
          };
          exports3.inherits = require2("inherits");
          exports3._extend = function(origin, add) {
            if (!add || !isObject(add)) return origin;
            var keys = Object.keys(add);
            var i = keys.length;
            while (i--) {
              origin[keys[i]] = add[keys[i]];
            }
            return origin;
          };
          function hasOwnProperty(obj, prop) {
            return Object.prototype.hasOwnProperty.call(obj, prop);
          }
        }).call(this, require2("_process"), typeof commonjsGlobal !== "undefined" ? commonjsGlobal : typeof self !== "undefined" ? self : typeof window !== "undefined" ? window : {});
      }, { "./support/isBuffer": 10, "_process": 14, "inherits": 9 }], 12: [function(require2, module3, exports3) {
      }, {}], 13: [function(require2, module3, exports3) {
        (function(process) {
          function normalizeArray(parts, allowAboveRoot) {
            var up = 0;
            for (var i = parts.length - 1; i >= 0; i--) {
              var last = parts[i];
              if (last === ".") {
                parts.splice(i, 1);
              } else if (last === "..") {
                parts.splice(i, 1);
                up++;
              } else if (up) {
                parts.splice(i, 1);
                up--;
              }
            }
            if (allowAboveRoot) {
              for (; up--; up) {
                parts.unshift("..");
              }
            }
            return parts;
          }
          exports3.resolve = function() {
            var resolvedPath = "", resolvedAbsolute = false;
            for (var i = arguments.length - 1; i >= -1 && !resolvedAbsolute; i--) {
              var path = i >= 0 ? arguments[i] : process.cwd();
              if (typeof path !== "string") {
                throw new TypeError("Arguments to path.resolve must be strings");
              } else if (!path) {
                continue;
              }
              resolvedPath = path + "/" + resolvedPath;
              resolvedAbsolute = path.charAt(0) === "/";
            }
            resolvedPath = normalizeArray(filter(resolvedPath.split("/"), function(p) {
              return !!p;
            }), !resolvedAbsolute).join("/");
            return (resolvedAbsolute ? "/" : "") + resolvedPath || ".";
          };
          exports3.normalize = function(path) {
            var isAbsolute = exports3.isAbsolute(path), trailingSlash = substr(path, -1) === "/";
            path = normalizeArray(filter(path.split("/"), function(p) {
              return !!p;
            }), !isAbsolute).join("/");
            if (!path && !isAbsolute) {
              path = ".";
            }
            if (path && trailingSlash) {
              path += "/";
            }
            return (isAbsolute ? "/" : "") + path;
          };
          exports3.isAbsolute = function(path) {
            return path.charAt(0) === "/";
          };
          exports3.join = function() {
            var paths = Array.prototype.slice.call(arguments, 0);
            return exports3.normalize(filter(paths, function(p, index) {
              if (typeof p !== "string") {
                throw new TypeError("Arguments to path.join must be strings");
              }
              return p;
            }).join("/"));
          };
          exports3.relative = function(from, to) {
            from = exports3.resolve(from).substr(1);
            to = exports3.resolve(to).substr(1);
            function trim(arr) {
              var start = 0;
              for (; start < arr.length; start++) {
                if (arr[start] !== "") break;
              }
              var end = arr.length - 1;
              for (; end >= 0; end--) {
                if (arr[end] !== "") break;
              }
              if (start > end) return [];
              return arr.slice(start, end - start + 1);
            }
            var fromParts = trim(from.split("/"));
            var toParts = trim(to.split("/"));
            var length = Math.min(fromParts.length, toParts.length);
            var samePartsLength = length;
            for (var i = 0; i < length; i++) {
              if (fromParts[i] !== toParts[i]) {
                samePartsLength = i;
                break;
              }
            }
            var outputParts = [];
            for (var i = samePartsLength; i < fromParts.length; i++) {
              outputParts.push("..");
            }
            outputParts = outputParts.concat(toParts.slice(samePartsLength));
            return outputParts.join("/");
          };
          exports3.sep = "/";
          exports3.delimiter = ":";
          exports3.dirname = function(path) {
            if (typeof path !== "string") path = path + "";
            if (path.length === 0) return ".";
            var code = path.charCodeAt(0);
            var hasRoot = code === 47;
            var end = -1;
            var matchedSlash = true;
            for (var i = path.length - 1; i >= 1; --i) {
              code = path.charCodeAt(i);
              if (code === 47) {
                if (!matchedSlash) {
                  end = i;
                  break;
                }
              } else {
                matchedSlash = false;
              }
            }
            if (end === -1) return hasRoot ? "/" : ".";
            if (hasRoot && end === 1) {
              return "/";
            }
            return path.slice(0, end);
          };
          function basename(path) {
            if (typeof path !== "string") path = path + "";
            var start = 0;
            var end = -1;
            var matchedSlash = true;
            var i;
            for (i = path.length - 1; i >= 0; --i) {
              if (path.charCodeAt(i) === 47) {
                if (!matchedSlash) {
                  start = i + 1;
                  break;
                }
              } else if (end === -1) {
                matchedSlash = false;
                end = i + 1;
              }
            }
            if (end === -1) return "";
            return path.slice(start, end);
          }
          exports3.basename = function(path, ext) {
            var f = basename(path);
            if (ext && f.substr(-1 * ext.length) === ext) {
              f = f.substr(0, f.length - ext.length);
            }
            return f;
          };
          exports3.extname = function(path) {
            if (typeof path !== "string") path = path + "";
            var startDot = -1;
            var startPart = 0;
            var end = -1;
            var matchedSlash = true;
            var preDotState = 0;
            for (var i = path.length - 1; i >= 0; --i) {
              var code = path.charCodeAt(i);
              if (code === 47) {
                if (!matchedSlash) {
                  startPart = i + 1;
                  break;
                }
                continue;
              }
              if (end === -1) {
                matchedSlash = false;
                end = i + 1;
              }
              if (code === 46) {
                if (startDot === -1)
                  startDot = i;
                else if (preDotState !== 1)
                  preDotState = 1;
              } else if (startDot !== -1) {
                preDotState = -1;
              }
            }
            if (startDot === -1 || end === -1 || // We saw a non-dot character immediately before the dot
            preDotState === 0 || // The (right-most) trimmed path component is exactly '..'
            preDotState === 1 && startDot === end - 1 && startDot === startPart + 1) {
              return "";
            }
            return path.slice(startDot, end);
          };
          function filter(xs, f) {
            if (xs.filter) return xs.filter(f);
            var res = [];
            for (var i = 0; i < xs.length; i++) {
              if (f(xs[i], i, xs)) res.push(xs[i]);
            }
            return res;
          }
          var substr = "ab".substr(-1) === "b" ? function(str, start, len) {
            return str.substr(start, len);
          } : function(str, start, len) {
            if (start < 0) start = str.length + start;
            return str.substr(start, len);
          };
        }).call(this, require2("_process"));
      }, { "_process": 14 }], 14: [function(require2, module3, exports3) {
        var process = module3.exports = {};
        var cachedSetTimeout;
        var cachedClearTimeout;
        function defaultSetTimout() {
          throw new Error("setTimeout has not been defined");
        }
        function defaultClearTimeout() {
          throw new Error("clearTimeout has not been defined");
        }
        (function() {
          try {
            if (typeof setTimeout === "function") {
              cachedSetTimeout = setTimeout;
            } else {
              cachedSetTimeout = defaultSetTimout;
            }
          } catch (e) {
            cachedSetTimeout = defaultSetTimout;
          }
          try {
            if (typeof clearTimeout === "function") {
              cachedClearTimeout = clearTimeout;
            } else {
              cachedClearTimeout = defaultClearTimeout;
            }
          } catch (e) {
            cachedClearTimeout = defaultClearTimeout;
          }
        })();
        function runTimeout(fun) {
          if (cachedSetTimeout === setTimeout) {
            return setTimeout(fun, 0);
          }
          if ((cachedSetTimeout === defaultSetTimout || !cachedSetTimeout) && setTimeout) {
            cachedSetTimeout = setTimeout;
            return setTimeout(fun, 0);
          }
          try {
            return cachedSetTimeout(fun, 0);
          } catch (e) {
            try {
              return cachedSetTimeout.call(null, fun, 0);
            } catch (e2) {
              return cachedSetTimeout.call(this, fun, 0);
            }
          }
        }
        function runClearTimeout(marker) {
          if (cachedClearTimeout === clearTimeout) {
            return clearTimeout(marker);
          }
          if ((cachedClearTimeout === defaultClearTimeout || !cachedClearTimeout) && clearTimeout) {
            cachedClearTimeout = clearTimeout;
            return clearTimeout(marker);
          }
          try {
            return cachedClearTimeout(marker);
          } catch (e) {
            try {
              return cachedClearTimeout.call(null, marker);
            } catch (e2) {
              return cachedClearTimeout.call(this, marker);
            }
          }
        }
        var queue = [];
        var draining = false;
        var currentQueue;
        var queueIndex = -1;
        function cleanUpNextTick() {
          if (!draining || !currentQueue) {
            return;
          }
          draining = false;
          if (currentQueue.length) {
            queue = currentQueue.concat(queue);
          } else {
            queueIndex = -1;
          }
          if (queue.length) {
            drainQueue();
          }
        }
        function drainQueue() {
          if (draining) {
            return;
          }
          var timeout = runTimeout(cleanUpNextTick);
          draining = true;
          var len = queue.length;
          while (len) {
            currentQueue = queue;
            queue = [];
            while (++queueIndex < len) {
              if (currentQueue) {
                currentQueue[queueIndex].run();
              }
            }
            queueIndex = -1;
            len = queue.length;
          }
          currentQueue = null;
          draining = false;
          runClearTimeout(timeout);
        }
        process.nextTick = function(fun) {
          var args = new Array(arguments.length - 1);
          if (arguments.length > 1) {
            for (var i = 1; i < arguments.length; i++) {
              args[i - 1] = arguments[i];
            }
          }
          queue.push(new Item(fun, args));
          if (queue.length === 1 && !draining) {
            runTimeout(drainQueue);
          }
        };
        function Item(fun, array) {
          this.fun = fun;
          this.array = array;
        }
        Item.prototype.run = function() {
          this.fun.apply(null, this.array);
        };
        process.title = "browser";
        process.browser = true;
        process.env = {};
        process.argv = [];
        process.version = "";
        process.versions = {};
        function noop() {
        }
        process.on = noop;
        process.addListener = noop;
        process.once = noop;
        process.off = noop;
        process.removeListener = noop;
        process.removeAllListeners = noop;
        process.emit = noop;
        process.prependListener = noop;
        process.prependOnceListener = noop;
        process.listeners = function(name) {
          return [];
        };
        process.binding = function(name) {
          throw new Error("process.binding is not supported");
        };
        process.cwd = function() {
          return "/";
        };
        process.chdir = function(dir) {
          throw new Error("process.chdir is not supported");
        };
        process.umask = function() {
          return 0;
        };
      }, {}], 15: [function(require2, module3, exports3) {
        var unparse = require2("escodegen").generate;
        module3.exports = function(ast, vars) {
          if (!vars) vars = {};
          var FAIL = {};
          var result = (function walk(node, scopeVars) {
            if (node.type === "Literal") {
              return node.value;
            } else if (node.type === "UnaryExpression") {
              var val = walk(node.argument);
              if (node.operator === "+") return +val;
              if (node.operator === "-") return -val;
              if (node.operator === "~") return ~val;
              if (node.operator === "!") return !val;
              return FAIL;
            } else if (node.type === "ArrayExpression") {
              var xs = [];
              for (var i = 0, l = node.elements.length; i < l; i++) {
                var x = walk(node.elements[i]);
                if (x === FAIL) return FAIL;
                xs.push(x);
              }
              return xs;
            } else if (node.type === "ObjectExpression") {
              var obj = {};
              for (var i = 0; i < node.properties.length; i++) {
                var prop = node.properties[i];
                var value = prop.value === null ? prop.value : walk(prop.value);
                if (value === FAIL) return FAIL;
                obj[prop.key.value || prop.key.name] = value;
              }
              return obj;
            } else if (node.type === "BinaryExpression" || node.type === "LogicalExpression") {
              var l = walk(node.left);
              if (l === FAIL) return FAIL;
              var r = walk(node.right);
              if (r === FAIL) return FAIL;
              var op = node.operator;
              if (op === "==") return l == r;
              if (op === "===") return l === r;
              if (op === "!=") return l != r;
              if (op === "!==") return l !== r;
              if (op === "+") return l + r;
              if (op === "-") return l - r;
              if (op === "*") return l * r;
              if (op === "/") return l / r;
              if (op === "%") return l % r;
              if (op === "<") return l < r;
              if (op === "<=") return l <= r;
              if (op === ">") return l > r;
              if (op === ">=") return l >= r;
              if (op === "|") return l | r;
              if (op === "&") return l & r;
              if (op === "^") return l ^ r;
              if (op === "&&") return l && r;
              if (op === "||") return l || r;
              return FAIL;
            } else if (node.type === "Identifier") {
              if ({}.hasOwnProperty.call(vars, node.name)) {
                return vars[node.name];
              } else return FAIL;
            } else if (node.type === "ThisExpression") {
              if ({}.hasOwnProperty.call(vars, "this")) {
                return vars["this"];
              } else return FAIL;
            } else if (node.type === "CallExpression") {
              var callee = walk(node.callee);
              if (callee === FAIL) return FAIL;
              if (typeof callee !== "function") return FAIL;
              var ctx = node.callee.object ? walk(node.callee.object) : FAIL;
              if (ctx === FAIL) ctx = null;
              var args = [];
              for (var i = 0, l = node.arguments.length; i < l; i++) {
                var x = walk(node.arguments[i]);
                if (x === FAIL) return FAIL;
                args.push(x);
              }
              return callee.apply(ctx, args);
            } else if (node.type === "MemberExpression") {
              var obj = walk(node.object);
              if (obj === FAIL || typeof obj == "function") {
                return FAIL;
              }
              if (node.property.type === "Identifier") {
                return obj[node.property.name];
              }
              var prop = walk(node.property);
              if (prop === FAIL) return FAIL;
              return obj[prop];
            } else if (node.type === "ConditionalExpression") {
              var val = walk(node.test);
              if (val === FAIL) return FAIL;
              return val ? walk(node.consequent) : walk(node.alternate);
            } else if (node.type === "ExpressionStatement") {
              var val = walk(node.expression);
              if (val === FAIL) return FAIL;
              return val;
            } else if (node.type === "ReturnStatement") {
              return walk(node.argument);
            } else if (node.type === "FunctionExpression") {
              var bodies = node.body.body;
              var oldVars = {};
              Object.keys(vars).forEach(function(element) {
                oldVars[element] = vars[element];
              });
              for (var i = 0; i < node.params.length; i++) {
                var key = node.params[i];
                if (key.type == "Identifier") {
                  vars[key.name] = null;
                } else return FAIL;
              }
              for (var i in bodies) {
                if (walk(bodies[i]) === FAIL) {
                  return FAIL;
                }
              }
              vars = oldVars;
              var keys = Object.keys(vars);
              var vals = keys.map(function(key2) {
                return vars[key2];
              });
              return Function(keys.join(", "), "return " + unparse(node)).apply(null, vals);
            } else if (node.type === "TemplateLiteral") {
              var str = "";
              for (var i = 0; i < node.expressions.length; i++) {
                str += walk(node.quasis[i]);
                str += walk(node.expressions[i]);
              }
              str += walk(node.quasis[i]);
              return str;
            } else if (node.type === "TaggedTemplateExpression") {
              var tag = walk(node.tag);
              var quasi = node.quasi;
              var strings = quasi.quasis.map(walk);
              var values = quasi.expressions.map(walk);
              return tag.apply(null, [strings].concat(values));
            } else if (node.type === "TemplateElement") {
              return node.value.cooked;
            } else return FAIL;
          })(ast);
          return result === FAIL ? void 0 : result;
        };
      }, { "escodegen": 12 }], "jsonpath": [function(require2, module3, exports3) {
        module3.exports = require2("./lib/index");
      }, { "./lib/index": 5 }] }, {}, ["jsonpath"])("jsonpath");
    });
  })(jsonpath);
  return jsonpath.exports;
}
var jsonpathExports = requireJsonpath();
const jp = /* @__PURE__ */ getDefaultExportFromCjs(jsonpathExports);
const _hoisted_1 = { class: "el-dropdown-link" };
const _sfc_main = /* @__PURE__ */ defineComponent({
  __name: "RunDataJsonActions",
  props: {
    node: {},
    paneType: {},
    pushRef: {},
    distanceFromActive: {},
    selectedJsonPath: { default: nonExistingJsonPath },
    jsonData: {},
    outputIndex: {},
    runIndex: {}
  },
  setup(__props) {
    const props = __props;
    const popOutWindow = inject(PopOutWindowKey, ref());
    const isInPopOutWindow = computed(() => popOutWindow?.value !== void 0);
    const ndvStore = useNDVStore();
    const workflowsStore = useWorkflowsStore();
    const clipboard = useClipboard();
    const i18n = useI18n();
    const nodeHelpers = useNodeHelpers();
    const { activeNode } = ndvStore;
    const pinnedData = usePinnedData(activeNode);
    const { showToast } = useToast();
    const telemetry = useTelemetry();
    const route = useRoute();
    const isReadOnlyRoute = computed(() => {
      return route?.meta?.readOnlyCanvas === true;
    });
    const noSelection = computed(() => {
      return props.selectedJsonPath === nonExistingJsonPath;
    });
    const normalisedJsonPath = computed(() => {
      return noSelection.value ? '[""]' : props.selectedJsonPath;
    });
    function getJsonValue() {
      let selectedValue = jp.query(props.jsonData, `$${normalisedJsonPath.value}`)[0];
      if (noSelection.value) {
        const inExecutionsFrame = window !== window.parent && window.parent.location.pathname.includes("/executions");
        if (pinnedData.hasData.value && !inExecutionsFrame) {
          selectedValue = clearJsonKey(pinnedData.data.value);
        } else {
          selectedValue = executionDataToJson(
            nodeHelpers.getNodeInputData(props.node, props.runIndex, props.outputIndex)
          );
        }
      }
      let value = "";
      if (typeof selectedValue === "object") {
        value = JSON.stringify(selectedValue, null, 2);
      } else {
        value = selectedValue.toString();
      }
      return value;
    }
    function getJsonItemPath() {
      const newPath = convertPath(normalisedJsonPath.value);
      let startPath = "";
      let path = "";
      const pathParts = newPath.split("]");
      const index = pathParts[0].slice(1);
      path = pathParts.slice(1).join("]");
      startPath = `$item(${index}).$node["${props.node.name}"].json`;
      return { path, startPath };
    }
    function getJsonParameterPath() {
      const newPath = convertPath(normalisedJsonPath.value);
      const path = newPath.split("]").slice(1).join("]");
      let startPath = `$node["${props.node.name}"].json`;
      if (props.distanceFromActive === 1) {
        startPath = "$json";
      }
      return { path, startPath };
    }
    function handleCopyClick(commandData) {
      let value;
      if (commandData.command === "value") {
        value = getJsonValue();
        showToast({
          title: i18n.baseText("runData.copyValue.toast"),
          message: "",
          type: "success",
          duration: 2e3
        });
      } else {
        let startPath = "";
        let path = "";
        if (commandData.command === "itemPath") {
          const jsonItemPath = getJsonItemPath();
          startPath = jsonItemPath.startPath;
          path = jsonItemPath.path;
          showToast({
            title: i18n.baseText("runData.copyItemPath.toast"),
            message: "",
            type: "success",
            duration: 2e3
          });
        } else if (commandData.command === "parameterPath") {
          const jsonParameterPath = getJsonParameterPath();
          startPath = jsonParameterPath.startPath;
          path = jsonParameterPath.path;
          showToast({
            title: i18n.baseText("runData.copyParameterPath.toast"),
            message: "",
            type: "success",
            duration: 2e3
          });
        }
        if (!path.startsWith("[") && !path.startsWith(".") && path) {
          path += ".";
        }
        value = `{{ ${startPath + path} }}`;
      }
      const copyType = {
        value: "selection",
        itemPath: "item_path",
        parameterPath: "parameter_path"
      }[commandData.command];
      telemetry.track("User copied ndv data", {
        node_type: activeNode?.type,
        push_ref: props.pushRef,
        run_index: props.runIndex,
        view: "json",
        copy_type: copyType,
        workflow_id: workflowsStore.workflowId,
        pane: props.paneType,
        in_execution_log: isReadOnlyRoute.value
      });
      void clipboard.copy(value);
    }
    return (_ctx, _cache) => {
      return openBlock(), createElementBlock("div", {
        class: normalizeClass(_ctx.$style.actionsGroup),
        "data-test-id": "ndv-json-actions"
      }, [
        noSelection.value ? (openBlock(), createBlock(unref(_sfc_main$1), {
          key: 0,
          title: unref(i18n).baseText("runData.copyToClipboard"),
          icon: "files",
          type: "tertiary",
          circle: false,
          onClick: _cache[0] || (_cache[0] = ($event) => handleCopyClick({ command: "value" }))
        }, null, 8, ["title"])) : (openBlock(), createBlock(unref(ElDropdown), {
          key: 1,
          trigger: "click",
          teleported: !isInPopOutWindow.value,
          onCommand: handleCopyClick
        }, {
          dropdown: withCtx(() => [
            createVNode(unref(ElDropdownMenu), null, {
              default: withCtx(() => [
                createVNode(unref(ElDropdownItem), { command: { command: "value" } }, {
                  default: withCtx(() => [
                    createTextVNode(toDisplayString(unref(i18n).baseText("runData.copyValue")), 1)
                  ]),
                  _: 1
                }),
                createVNode(unref(ElDropdownItem), {
                  command: { command: "itemPath" },
                  divided: ""
                }, {
                  default: withCtx(() => [
                    createTextVNode(toDisplayString(unref(i18n).baseText("runData.copyItemPath")), 1)
                  ]),
                  _: 1
                }),
                createVNode(unref(ElDropdownItem), { command: { command: "parameterPath" } }, {
                  default: withCtx(() => [
                    createTextVNode(toDisplayString(unref(i18n).baseText("runData.copyParameterPath")), 1)
                  ]),
                  _: 1
                })
              ]),
              _: 1
            })
          ]),
          default: withCtx(() => [
            createBaseVNode("span", _hoisted_1, [
              createVNode(unref(_sfc_main$1), {
                title: unref(i18n).baseText("runData.copyToClipboard"),
                icon: "files",
                type: "tertiary",
                circle: false
              }, null, 8, ["title"])
            ])
          ]),
          _: 1
        }, 8, ["teleported"]))
      ], 2);
    };
  }
});
const actionsGroup = "_actionsGroup_hbcos_123";
const style0 = {
  actionsGroup
};
const cssModules = {
  "$style": style0
};
const RunDataJsonActions = /* @__PURE__ */ _export_sfc(_sfc_main, [["__cssModules", cssModules]]);
export {
  RunDataJsonActions as default
};