@builder.io/sdk-solid 0.4.5 → 0.5.1

package/src/functions/evaluate/acorn.js

@@ -0,0 +1,1595 @@
+var __commonJS = (cb, mod) => function __require() {
+  return mod || (0, cb[Object.keys(cb)[0]])((mod = {
+    exports: {}
+  }).exports, mod), mod.exports;
+};
+var require_stdin = __commonJS({
+  "<stdin>"(exports, module) {
+    /**
+     * @license
+     * Copyright 2012 Marijn Haverbeke
+     * SPDX-License-Identifier: MIT
+     */
+    (function (root, mod) {
+      if (typeof exports === "object" && typeof module === "object") return mod(exports);
+      if (typeof define === "function" && define.amd) return define(["exports"], mod);
+      mod(root.acorn || (root.acorn = {}));
+    })(exports, function (exports2) {
+      exports2.version = "0.5.0";
+      var options;
+      var input = "";
+      var inputLen;
+      var sourceFile;
+      exports2.parse = function (inpt, opts) {
+        input = String(inpt);
+        inputLen = input.length;
+        setOptions(opts);
+        initTokenState();
+        return parseTopLevel(options.program);
+      };
+      var defaultOptions = {
+        strictSemicolons: false,
+        allowTrailingCommas: true,
+        forbidReserved: false,
+        allowReturnOutsideFunction: false,
+        locations: false,
+        onComment: null,
+        ranges: false,
+        program: null,
+        sourceFile: null,
+        directSourceFile: null
+      };
+      function setOptions(opts) {
+        options = opts || {};
+        for (var opt in defaultOptions) {
+          if (!Object.prototype.hasOwnProperty.call(options, opt)) {
+            options[opt] = defaultOptions[opt];
+          }
+        }
+        sourceFile = options.sourceFile;
+      }
+      var getLineInfo = function (input2, offset) {
+        for (var line = 1, cur = 0;;) {
+          lineBreak.lastIndex = cur;
+          var match = lineBreak.exec(input2);
+          if (match && match.index < offset) {
+            ++line;
+            cur = match.index + match[0].length;
+          } else {
+            break;
+          }
+        }
+        return {
+          line,
+          column: offset - cur
+        };
+      };
+      var tokPos = 0;
+      var tokStart = 0;
+      var tokEnd = 0;
+      var tokStartLoc;
+      var tokEndLoc;
+      var tokType;
+      var tokVal;
+      var tokRegexpAllowed;
+      var tokCurLine;
+      var tokLineStart;
+      var lastStart = 0;
+      var lastEnd = 0;
+      var lastEndLoc;
+      var inFunction;
+      var labels;
+      var strict;
+      function raise(pos, message) {
+        var loc = getLineInfo(input, pos);
+        message += " (" + loc.line + ":" + loc.column + ")";
+        var err = new SyntaxError(message);
+        err.pos = pos;
+        err.loc = loc;
+        err.raisedAt = tokPos;
+        throw err;
+      }
+      var empty = [];
+      var _num = {
+        type: "num"
+      };
+      var _regexp = {
+        type: "regexp"
+      };
+      var _string = {
+        type: "string"
+      };
+      var _name = {
+        type: "name"
+      };
+      var _eof = {
+        type: "eof"
+      };
+      var _break = {
+        keyword: "break"
+      };
+      var _case = {
+        keyword: "case",
+        beforeExpr: true
+      };
+      var _catch = {
+        keyword: "catch"
+      };
+      var _continue = {
+        keyword: "continue"
+      };
+      var _debugger = {
+        keyword: "debugger"
+      };
+      var _default = {
+        keyword: "default"
+      };
+      var _do = {
+        keyword: "do",
+        isLoop: true
+      };
+      var _else = {
+        keyword: "else",
+        beforeExpr: true
+      };
+      var _finally = {
+        keyword: "finally"
+      };
+      var _for = {
+        keyword: "for",
+        isLoop: true
+      };
+      var _function = {
+        keyword: "function"
+      };
+      var _if = {
+        keyword: "if"
+      };
+      var _return = {
+        keyword: "return",
+        beforeExpr: true
+      };
+      var _switch = {
+        keyword: "switch"
+      };
+      var _throw = {
+        keyword: "throw",
+        beforeExpr: true
+      };
+      var _try = {
+        keyword: "try"
+      };
+      var _var = {
+        keyword: "var"
+      };
+      var _while = {
+        keyword: "while",
+        isLoop: true
+      };
+      var _with = {
+        keyword: "with"
+      };
+      var _new = {
+        keyword: "new",
+        beforeExpr: true
+      };
+      var _this = {
+        keyword: "this"
+      };
+      var _null = {
+        keyword: "null",
+        atomValue: null
+      };
+      var _true = {
+        keyword: "true",
+        atomValue: true
+      };
+      var _false = {
+        keyword: "false",
+        atomValue: false
+      };
+      var _in = {
+        keyword: "in",
+        binop: 7,
+        beforeExpr: true
+      };
+      var keywordTypes = {
+        break: _break,
+        case: _case,
+        catch: _catch,
+        continue: _continue,
+        debugger: _debugger,
+        default: _default,
+        do: _do,
+        else: _else,
+        finally: _finally,
+        for: _for,
+        function: _function,
+        if: _if,
+        return: _return,
+        switch: _switch,
+        throw: _throw,
+        try: _try,
+        var: _var,
+        while: _while,
+        with: _with,
+        null: _null,
+        true: _true,
+        false: _false,
+        new: _new,
+        in: _in,
+        instanceof: {
+          keyword: "instanceof",
+          binop: 7,
+          beforeExpr: true
+        },
+        this: _this,
+        typeof: {
+          keyword: "typeof",
+          prefix: true,
+          beforeExpr: true
+        },
+        void: {
+          keyword: "void",
+          prefix: true,
+          beforeExpr: true
+        },
+        delete: {
+          keyword: "delete",
+          prefix: true,
+          beforeExpr: true
+        }
+      };
+      var _bracketL = {
+        type: "[",
+        beforeExpr: true
+      };
+      var _bracketR = {
+        type: "]"
+      };
+      var _braceL = {
+        type: "{",
+        beforeExpr: true
+      };
+      var _braceR = {
+        type: "}"
+      };
+      var _parenL = {
+        type: "(",
+        beforeExpr: true
+      };
+      var _parenR = {
+        type: ")"
+      };
+      var _comma = {
+        type: ",",
+        beforeExpr: true
+      };
+      var _semi = {
+        type: ";",
+        beforeExpr: true
+      };
+      var _colon = {
+        type: ":",
+        beforeExpr: true
+      };
+      var _dot = {
+        type: "."
+      };
+      var _question = {
+        type: "?",
+        beforeExpr: true
+      };
+      var _slash = {
+        binop: 10,
+        beforeExpr: true
+      };
+      var _eq = {
+        isAssign: true,
+        beforeExpr: true
+      };
+      var _assign = {
+        isAssign: true,
+        beforeExpr: true
+      };
+      var _incDec = {
+        postfix: true,
+        prefix: true,
+        isUpdate: true
+      };
+      var _prefix = {
+        prefix: true,
+        beforeExpr: true
+      };
+      var _logicalOR = {
+        binop: 1,
+        beforeExpr: true
+      };
+      var _logicalAND = {
+        binop: 2,
+        beforeExpr: true
+      };
+      var _bitwiseOR = {
+        binop: 3,
+        beforeExpr: true
+      };
+      var _bitwiseXOR = {
+        binop: 4,
+        beforeExpr: true
+      };
+      var _bitwiseAND = {
+        binop: 5,
+        beforeExpr: true
+      };
+      var _equality = {
+        binop: 6,
+        beforeExpr: true
+      };
+      var _relational = {
+        binop: 7,
+        beforeExpr: true
+      };
+      var _bitShift = {
+        binop: 8,
+        beforeExpr: true
+      };
+      var _plusMin = {
+        binop: 9,
+        prefix: true,
+        beforeExpr: true
+      };
+      var _multiplyModulo = {
+        binop: 10,
+        beforeExpr: true
+      };
+      function makePredicate(words) {
+        var wordList = words.split(" ");
+        var set = Object.create(null);
+        for (var i = 0; i < wordList.length; i++) {
+          set[wordList[i]] = true;
+        }
+        return function (str) {
+          return set[str] || false;
+        };
+      }
+      var isReservedWord5 = makePredicate("class enum extends super const export import");
+      var isStrictReservedWord = makePredicate("implements interface let package private protected public static yield");
+      var isStrictBadIdWord = makePredicate("eval arguments");
+      var isKeyword = makePredicate("break case catch continue debugger default do else finally for function if return switch throw try var while with null true false instanceof typeof void delete new in this");
+      var nonASCIIwhitespace = /[\u1680\u180e\u2000-\u200a\u202f\u205f\u3000\ufeff]/;
+      var nonASCIIidentifierStartChars = "\xAA\xB5\xBA\xC0-\xD6\xD8-\xF6\xF8-\u02C1\u02C6-\u02D1\u02E0-\u02E4\u02EC\u02EE\u0370-\u0374\u0376\u0377\u037A-\u037D\u0386\u0388-\u038A\u038C\u038E-\u03A1\u03A3-\u03F5\u03F7-\u0481\u048A-\u0527\u0531-\u0556\u0559\u0561-\u0587\u05D0-\u05EA\u05F0-\u05F2\u0620-\u064A\u066E\u066F\u0671-\u06D3\u06D5\u06E5\u06E6\u06EE\u06EF\u06FA-\u06FC\u06FF\u0710\u0712-\u072F\u074D-\u07A5\u07B1\u07CA-\u07EA\u07F4\u07F5\u07FA\u0800-\u0815\u081A\u0824\u0828\u0840-\u0858\u08A0\u08A2-\u08AC\u0904-\u0939\u093D\u0950\u0958-\u0961\u0971-\u0977\u0979-\u097F\u0985-\u098C\u098F\u0990\u0993-\u09A8\u09AA-\u09B0\u09B2\u09B6-\u09B9\u09BD\u09CE\u09DC\u09DD\u09DF-\u09E1\u09F0\u09F1\u0A05-\u0A0A\u0A0F\u0A10\u0A13-\u0A28\u0A2A-\u0A30\u0A32\u0A33\u0A35\u0A36\u0A38\u0A39\u0A59-\u0A5C\u0A5E\u0A72-\u0A74\u0A85-\u0A8D\u0A8F-\u0A91\u0A93-\u0AA8\u0AAA-\u0AB0\u0AB2\u0AB3\u0AB5-\u0AB9\u0ABD\u0AD0\u0AE0\u0AE1\u0B05-\u0B0C\u0B0F\u0B10\u0B13-\u0B28\u0B2A-\u0B30\u0B32\u0B33\u0B35-\u0B39\u0B3D\u0B5C\u0B5D\u0B5F-\u0B61\u0B71\u0B83\u0B85-\u0B8A\u0B8E-\u0B90\u0B92-\u0B95\u0B99\u0B9A\u0B9C\u0B9E\u0B9F\u0BA3\u0BA4\u0BA8-\u0BAA\u0BAE-\u0BB9\u0BD0\u0C05-\u0C0C\u0C0E-\u0C10\u0C12-\u0C28\u0C2A-\u0C33\u0C35-\u0C39\u0C3D\u0C58\u0C59\u0C60\u0C61\u0C85-\u0C8C\u0C8E-\u0C90\u0C92-\u0CA8\u0CAA-\u0CB3\u0CB5-\u0CB9\u0CBD\u0CDE\u0CE0\u0CE1\u0CF1\u0CF2\u0D05-\u0D0C\u0D0E-\u0D10\u0D12-\u0D3A\u0D3D\u0D4E\u0D60\u0D61\u0D7A-\u0D7F\u0D85-\u0D96\u0D9A-\u0DB1\u0DB3-\u0DBB\u0DBD\u0DC0-\u0DC6\u0E01-\u0E30\u0E32\u0E33\u0E40-\u0E46\u0E81\u0E82\u0E84\u0E87\u0E88\u0E8A\u0E8D\u0E94-\u0E97\u0E99-\u0E9F\u0EA1-\u0EA3\u0EA5\u0EA7\u0EAA\u0EAB\u0EAD-\u0EB0\u0EB2\u0EB3\u0EBD\u0EC0-\u0EC4\u0EC6\u0EDC-\u0EDF\u0F00\u0F40-\u0F47\u0F49-\u0F6C\u0F88-\u0F8C\u1000-\u102A\u103F\u1050-\u1055\u105A-\u105D\u1061\u1065\u1066\u106E-\u1070\u1075-\u1081\u108E\u10A0-\u10C5\u10C7\u10CD\u10D0-\u10FA\u10FC-\u1248\u124A-\u124D\u1250-\u1256\u1258\u125A-\u125D\u1260-\u1288\u128A-\u128D\u1290-\u12B0\u12B2-\u12B5\u12B8-\u12BE\u12C0\u12C2-\u12C5\u12C8-\u12D6\u12D8-\u1310\u1312-\u1315\u1318-\u135A\u1380-\u138F\u13A0-\u13F4\u1401-\u166C\u166F-\u167F\u1681-\u169A\u16A0-\u16EA\u16EE-\u16F0\u1700-\u170C\u170E-\u1711\u1720-\u1731\u1740-\u1751\u1760-\u176C\u176E-\u1770\u1780-\u17B3\u17D7\u17DC\u1820-\u1877\u1880-\u18A8\u18AA\u18B0-\u18F5\u1900-\u191C\u1950-\u196D\u1970-\u1974\u1980-\u19AB\u19C1-\u19C7\u1A00-\u1A16\u1A20-\u1A54\u1AA7\u1B05-\u1B33\u1B45-\u1B4B\u1B83-\u1BA0\u1BAE\u1BAF\u1BBA-\u1BE5\u1C00-\u1C23\u1C4D-\u1C4F\u1C5A-\u1C7D\u1CE9-\u1CEC\u1CEE-\u1CF1\u1CF5\u1CF6\u1D00-\u1DBF\u1E00-\u1F15\u1F18-\u1F1D\u1F20-\u1F45\u1F48-\u1F4D\u1F50-\u1F57\u1F59\u1F5B\u1F5D\u1F5F-\u1F7D\u1F80-\u1FB4\u1FB6-\u1FBC\u1FBE\u1FC2-\u1FC4\u1FC6-\u1FCC\u1FD0-\u1FD3\u1FD6-\u1FDB\u1FE0-\u1FEC\u1FF2-\u1FF4\u1FF6-\u1FFC\u2071\u207F\u2090-\u209C\u2102\u2107\u210A-\u2113\u2115\u2119-\u211D\u2124\u2126\u2128\u212A-\u212D\u212F-\u2139\u213C-\u213F\u2145-\u2149\u214E\u2160-\u2188\u2C00-\u2C2E\u2C30-\u2C5E\u2C60-\u2CE4\u2CEB-\u2CEE\u2CF2\u2CF3\u2D00-\u2D25\u2D27\u2D2D\u2D30-\u2D67\u2D6F\u2D80-\u2D96\u2DA0-\u2DA6\u2DA8-\u2DAE\u2DB0-\u2DB6\u2DB8-\u2DBE\u2DC0-\u2DC6\u2DC8-\u2DCE\u2DD0-\u2DD6\u2DD8-\u2DDE\u2E2F\u3005-\u3007\u3021-\u3029\u3031-\u3035\u3038-\u303C\u3041-\u3096\u309D-\u309F\u30A1-\u30FA\u30FC-\u30FF\u3105-\u312D\u3131-\u318E\u31A0-\u31BA\u31F0-\u31FF\u3400-\u4DB5\u4E00-\u9FCC\uA000-\uA48C\uA4D0-\uA4FD\uA500-\uA60C\uA610-\uA61F\uA62A\uA62B\uA640-\uA66E\uA67F-\uA697\uA6A0-\uA6EF\uA717-\uA71F\uA722-\uA788\uA78B-\uA78E\uA790-\uA793\uA7A0-\uA7AA\uA7F8-\uA801\uA803-\uA805\uA807-\uA80A\uA80C-\uA822\uA840-\uA873\uA882-\uA8B3\uA8F2-\uA8F7\uA8FB\uA90A-\uA925\uA930-\uA946\uA960-\uA97C\uA984-\uA9B2\uA9CF\uAA00-\uAA28\uAA40-\uAA42\uAA44-\uAA4B\uAA60-\uAA76\uAA7A\uAA80-\uAAAF\uAAB1\uAAB5\uAAB6\uAAB9-\uAABD\uAAC0\uAAC2\uAADB-\uAADD\uAAE0-\uAAEA\uAAF2-\uAAF4\uAB01-\uAB06\uAB09-\uAB0E\uAB11-\uAB16\uAB20-\uAB26\uAB28-\uAB2E\uABC0-\uABE2\uAC00-\uD7A3\uD7B0-\uD7C6\uD7CB-\uD7FB\uF900-\uFA6D\uFA70-\uFAD9\uFB00-\uFB06\uFB13-\uFB17\uFB1D\uFB1F-\uFB28\uFB2A-\uFB36\uFB38-\uFB3C\uFB3E\uFB40\uFB41\uFB43\uFB44\uFB46-\uFBB1\uFBD3-\uFD3D\uFD50-\uFD8F\uFD92-\uFDC7\uFDF0-\uFDFB\uFE70-\uFE74\uFE76-\uFEFC\uFF21-\uFF3A\uFF41-\uFF5A\uFF66-\uFFBE\uFFC2-\uFFC7\uFFCA-\uFFCF\uFFD2-\uFFD7\uFFDA-\uFFDC";
+      var nonASCIIidentifierChars = "\u0300-\u036F\u0483-\u0487\u0591-\u05BD\u05BF\u05C1\u05C2\u05C4\u05C5\u05C7\u0610-\u061A\u0620-\u0649\u0672-\u06D3\u06E7-\u06E8\u06FB-\u06FC\u0730-\u074A\u0800-\u0814\u081B-\u0823\u0825-\u0827\u0829-\u082D\u0840-\u0857\u08E4-\u08FE\u0900-\u0903\u093A-\u093C\u093E-\u094F\u0951-\u0957\u0962-\u0963\u0966-\u096F\u0981-\u0983\u09BC\u09BE-\u09C4\u09C7\u09C8\u09D7\u09DF-\u09E0\u0A01-\u0A03\u0A3C\u0A3E-\u0A42\u0A47\u0A48\u0A4B-\u0A4D\u0A51\u0A66-\u0A71\u0A75\u0A81-\u0A83\u0ABC\u0ABE-\u0AC5\u0AC7-\u0AC9\u0ACB-\u0ACD\u0AE2-\u0AE3\u0AE6-\u0AEF\u0B01-\u0B03\u0B3C\u0B3E-\u0B44\u0B47\u0B48\u0B4B-\u0B4D\u0B56\u0B57\u0B5F-\u0B60\u0B66-\u0B6F\u0B82\u0BBE-\u0BC2\u0BC6-\u0BC8\u0BCA-\u0BCD\u0BD7\u0BE6-\u0BEF\u0C01-\u0C03\u0C46-\u0C48\u0C4A-\u0C4D\u0C55\u0C56\u0C62-\u0C63\u0C66-\u0C6F\u0C82\u0C83\u0CBC\u0CBE-\u0CC4\u0CC6-\u0CC8\u0CCA-\u0CCD\u0CD5\u0CD6\u0CE2-\u0CE3\u0CE6-\u0CEF\u0D02\u0D03\u0D46-\u0D48\u0D57\u0D62-\u0D63\u0D66-\u0D6F\u0D82\u0D83\u0DCA\u0DCF-\u0DD4\u0DD6\u0DD8-\u0DDF\u0DF2\u0DF3\u0E34-\u0E3A\u0E40-\u0E45\u0E50-\u0E59\u0EB4-\u0EB9\u0EC8-\u0ECD\u0ED0-\u0ED9\u0F18\u0F19\u0F20-\u0F29\u0F35\u0F37\u0F39\u0F41-\u0F47\u0F71-\u0F84\u0F86-\u0F87\u0F8D-\u0F97\u0F99-\u0FBC\u0FC6\u1000-\u1029\u1040-\u1049\u1067-\u106D\u1071-\u1074\u1082-\u108D\u108F-\u109D\u135D-\u135F\u170E-\u1710\u1720-\u1730\u1740-\u1750\u1772\u1773\u1780-\u17B2\u17DD\u17E0-\u17E9\u180B-\u180D\u1810-\u1819\u1920-\u192B\u1930-\u193B\u1951-\u196D\u19B0-\u19C0\u19C8-\u19C9\u19D0-\u19D9\u1A00-\u1A15\u1A20-\u1A53\u1A60-\u1A7C\u1A7F-\u1A89\u1A90-\u1A99\u1B46-\u1B4B\u1B50-\u1B59\u1B6B-\u1B73\u1BB0-\u1BB9\u1BE6-\u1BF3\u1C00-\u1C22\u1C40-\u1C49\u1C5B-\u1C7D\u1CD0-\u1CD2\u1D00-\u1DBE\u1E01-\u1F15\u200C\u200D\u203F\u2040\u2054\u20D0-\u20DC\u20E1\u20E5-\u20F0\u2D81-\u2D96\u2DE0-\u2DFF\u3021-\u3028\u3099\u309A\uA640-\uA66D\uA674-\uA67D\uA69F\uA6F0-\uA6F1\uA7F8-\uA800\uA806\uA80B\uA823-\uA827\uA880-\uA881\uA8B4-\uA8C4\uA8D0-\uA8D9\uA8F3-\uA8F7\uA900-\uA909\uA926-\uA92D\uA930-\uA945\uA980-\uA983\uA9B3-\uA9C0\uAA00-\uAA27\uAA40-\uAA41\uAA4C-\uAA4D\uAA50-\uAA59\uAA7B\uAAE0-\uAAE9\uAAF2-\uAAF3\uABC0-\uABE1\uABEC\uABED\uABF0-\uABF9\uFB20-\uFB28\uFE00-\uFE0F\uFE20-\uFE26\uFE33\uFE34\uFE4D-\uFE4F\uFF10-\uFF19\uFF3F";
+      var nonASCIIidentifierStart = new RegExp("[" + nonASCIIidentifierStartChars + "]");
+      var nonASCIIidentifier = new RegExp("[" + nonASCIIidentifierStartChars + nonASCIIidentifierChars + "]");
+      var newline = /[\n\r\u2028\u2029]/;
+      var lineBreak = /\r\n|[\n\r\u2028\u2029]/g;
+      var isIdentifierStart = function (code) {
+        if (code < 65) return code === 36;
+        if (code < 91) return true;
+        if (code < 97) return code === 95;
+        if (code < 123) return true;
+        return code >= 170 && nonASCIIidentifierStart.test(String.fromCharCode(code));
+      };
+      var isIdentifierChar = function (code) {
+        if (code < 48) return code === 36;
+        if (code < 58) return true;
+        if (code < 65) return false;
+        if (code < 91) return true;
+        if (code < 97) return code === 95;
+        if (code < 123) return true;
+        return code >= 170 && nonASCIIidentifier.test(String.fromCharCode(code));
+      };
+      function line_loc_t() {
+        this.line = tokCurLine;
+        this.column = tokPos - tokLineStart;
+      }
+      function initTokenState() {
+        tokCurLine = 1;
+        tokPos = tokLineStart = 0;
+        tokRegexpAllowed = true;
+        skipSpace();
+      }
+      function finishToken(type, val) {
+        tokEnd = tokPos;
+        if (options.locations) {
+          tokEndLoc = new line_loc_t();
+        }
+        tokType = type;
+        skipSpace();
+        tokVal = val;
+        tokRegexpAllowed = type.beforeExpr;
+      }
+      function skipBlockComment() {
+        var startLoc = options.onComment && options.locations && new line_loc_t();
+        var start = tokPos;
+        var end = input.indexOf("*/", tokPos += 2);
+        if (end === -1) {
+          raise(tokPos - 2, "Unterminated comment");
+        }
+        tokPos = end + 2;
+        if (options.locations) {
+          lineBreak.lastIndex = start;
+          var match;
+          while ((match = lineBreak.exec(input)) && match.index < tokPos) {
+            ++tokCurLine;
+            tokLineStart = match.index + match[0].length;
+          }
+        }
+        if (options.onComment) {
+          options.onComment(true, input.slice(start + 2, end), start, tokPos, startLoc, options.locations && new line_loc_t());
+        }
+      }
+      function skipLineComment() {
+        var start = tokPos;
+        var startLoc = options.onComment && options.locations && new line_loc_t();
+        var ch = input.charCodeAt(tokPos += 2);
+        while (tokPos < inputLen && ch !== 10 && ch !== 13 && ch !== 8232 && ch !== 8233) {
+          ++tokPos;
+          ch = input.charCodeAt(tokPos);
+        }
+        if (options.onComment) {
+          options.onComment(false, input.slice(start + 2, tokPos), start, tokPos, startLoc, options.locations && new line_loc_t());
+        }
+      }
+      function skipSpace() {
+        while (tokPos < inputLen) {
+          var ch = input.charCodeAt(tokPos);
+          if (ch === 32) {
+            ++tokPos;
+          } else if (ch === 13) {
+            ++tokPos;
+            var next2 = input.charCodeAt(tokPos);
+            if (next2 === 10) {
+              ++tokPos;
+            }
+            if (options.locations) {
+              ++tokCurLine;
+              tokLineStart = tokPos;
+            }
+          } else if (ch === 10 || ch === 8232 || ch === 8233) {
+            ++tokPos;
+            if (options.locations) {
+              ++tokCurLine;
+              tokLineStart = tokPos;
+            }
+          } else if (ch > 8 && ch < 14) {
+            ++tokPos;
+          } else if (ch === 47) {
+            var next2 = input.charCodeAt(tokPos + 1);
+            if (next2 === 42) {
+              skipBlockComment();
+            } else if (next2 === 47) {
+              skipLineComment();
+            } else break;
+          } else if (ch === 160) {
+            ++tokPos;
+          } else if (ch >= 5760 && nonASCIIwhitespace.test(String.fromCharCode(ch))) {
+            ++tokPos;
+          } else {
+            break;
+          }
+        }
+      }
+      function readToken_dot() {
+        var next2 = input.charCodeAt(tokPos + 1);
+        if (next2 >= 48 && next2 <= 57) {
+          readNumber(true);
+        } else {
+          ++tokPos;
+          finishToken(_dot);
+        }
+      }
+      function readToken_slash() {
+        var next2 = input.charCodeAt(tokPos + 1);
+        if (tokRegexpAllowed) {
+          ++tokPos;
+          readRegexp();
+        } else if (next2 === 61) {
+          finishOp(_assign, 2);
+        } else {
+          finishOp(_slash, 1);
+        }
+      }
+      function readToken_mult_modulo() {
+        var next2 = input.charCodeAt(tokPos + 1);
+        if (next2 === 61) {
+          finishOp(_assign, 2);
+        } else {
+          finishOp(_multiplyModulo, 1);
+        }
+      }
+      function readToken_pipe_amp(code) {
+        var next2 = input.charCodeAt(tokPos + 1);
+        if (next2 === code) {
+          finishOp(code === 124 ? _logicalOR : _logicalAND, 2);
+        } else if (next2 === 61) {
+          finishOp(_assign, 2);
+        } else {
+          finishOp(code === 124 ? _bitwiseOR : _bitwiseAND, 1);
+        }
+      }
+      function readToken_caret() {
+        var next2 = input.charCodeAt(tokPos + 1);
+        if (next2 === 61) {
+          finishOp(_assign, 2);
+        } else {
+          finishOp(_bitwiseXOR, 1);
+        }
+      }
+      function readToken_plus_min(code) {
+        var next2 = input.charCodeAt(tokPos + 1);
+        if (next2 === code) {
+          if (next2 === 45 && input.charCodeAt(tokPos + 2) === 62 && newline.test(input.slice(lastEnd, tokPos))) {
+            tokPos += 3;
+            skipLineComment();
+            skipSpace();
+            readToken();
+            return;
+          }
+          finishOp(_incDec, 2);
+        } else if (next2 === 61) {
+          finishOp(_assign, 2);
+        } else {
+          finishOp(_plusMin, 1);
+        }
+      }
+      function readToken_lt_gt(code) {
+        var next2 = input.charCodeAt(tokPos + 1);
+        var size = 1;
+        if (next2 === code) {
+          size = code === 62 && input.charCodeAt(tokPos + 2) === 62 ? 3 : 2;
+          if (input.charCodeAt(tokPos + size) === 61) {
+            finishOp(_assign, size + 1);
+          } else {
+            finishOp(_bitShift, size);
+          }
+          return;
+        }
+        if (next2 === 33 && code === 60 && input.charCodeAt(tokPos + 2) === 45 && input.charCodeAt(tokPos + 3) === 45) {
+          tokPos += 4;
+          skipLineComment();
+          skipSpace();
+          readToken();
+          return;
+        }
+        if (next2 === 61) {
+          size = input.charCodeAt(tokPos + 2) === 61 ? 3 : 2;
+        }
+        finishOp(_relational, size);
+      }
+      function readToken_eq_excl(code) {
+        var next2 = input.charCodeAt(tokPos + 1);
+        if (next2 === 61) {
+          finishOp(_equality, input.charCodeAt(tokPos + 2) === 61 ? 3 : 2);
+        } else {
+          finishOp(code === 61 ? _eq : _prefix, 1);
+        }
+      }
+      function getTokenFromCode(code) {
+        switch (code) {
+          case 46:
+            return readToken_dot();
+          case 40:
+            ++tokPos;
+            return finishToken(_parenL);
+          case 41:
+            ++tokPos;
+            return finishToken(_parenR);
+          case 59:
+            ++tokPos;
+            return finishToken(_semi);
+          case 44:
+            ++tokPos;
+            return finishToken(_comma);
+          case 91:
+            ++tokPos;
+            return finishToken(_bracketL);
+          case 93:
+            ++tokPos;
+            return finishToken(_bracketR);
+          case 123:
+            ++tokPos;
+            return finishToken(_braceL);
+          case 125:
+            ++tokPos;
+            return finishToken(_braceR);
+          case 58:
+            ++tokPos;
+            return finishToken(_colon);
+          case 63:
+            ++tokPos;
+            return finishToken(_question);
+          case 48:
+            var next2 = input.charCodeAt(tokPos + 1);
+            if (next2 === 120 || next2 === 88) return readHexNumber();
+          case 49:
+          case 50:
+          case 51:
+          case 52:
+          case 53:
+          case 54:
+          case 55:
+          case 56:
+          case 57:
+            return readNumber(false);
+          case 34:
+          case 39:
+            return readString(code);
+          case 47:
+            return readToken_slash();
+          case 37:
+          case 42:
+            return readToken_mult_modulo();
+          case 124:
+          case 38:
+            return readToken_pipe_amp(code);
+          case 94:
+            return readToken_caret();
+          case 43:
+          case 45:
+            return readToken_plus_min(code);
+          case 60:
+          case 62:
+            return readToken_lt_gt(code);
+          case 61:
+          case 33:
+            return readToken_eq_excl(code);
+          case 126:
+            return finishOp(_prefix, 1);
+        }
+        return false;
+      }
+      function readToken(forceRegexp) {
+        if (!forceRegexp) {
+          tokStart = tokPos;
+        } else {
+          tokPos = tokStart + 1;
+        }
+        if (options.locations) {
+          tokStartLoc = new line_loc_t();
+        }
+        if (forceRegexp) return readRegexp();
+        if (tokPos >= inputLen) return finishToken(_eof);
+        var code = input.charCodeAt(tokPos);
+        if (isIdentifierStart(code) || code === 92) {
+          return readWord();
+        }
+        var tok = getTokenFromCode(code);
+        if (tok === false) {
+          var ch = String.fromCharCode(code);
+          if (ch === "\\" || nonASCIIidentifierStart.test(ch)) {
+            return readWord();
+          }
+          raise(tokPos, "Unexpected character '" + ch + "'");
+        }
+      }
+      function finishOp(type, size) {
+        var str = input.slice(tokPos, tokPos + size);
+        tokPos += size;
+        finishToken(type, str);
+      }
+      function readRegexp() {
+        var escaped;
+        var inClass;
+        var start = tokPos;
+        for (;;) {
+          if (tokPos >= inputLen) raise(start, "Unterminated regexp");
+          var ch = input.charAt(tokPos);
+          if (newline.test(ch)) raise(start, "Unterminated regexp");
+          if (!escaped) {
+            if (ch === "[") {
+              inClass = true;
+            } else if (ch === "]" && inClass) {
+              inClass = false;
+            } else if (ch === "/" && !inClass) {
+              break;
+            }
+            escaped = ch === "\\";
+          } else escaped = false;
+          ++tokPos;
+        }
+        var content = input.slice(start, tokPos);
+        ++tokPos;
+        var mods = readWord1();
+        if (mods && !/^[gmi]*$/.test(mods)) {
+          raise(start, "Invalid regexp flag");
+        }
+        try {
+          var value = new RegExp(content, mods);
+        } catch (e) {
+          if (e instanceof SyntaxError) raise(start, e.message);
+          throw e;
+        }
+        finishToken(_regexp, value);
+      }
+      function readInt(radix, len) {
+        var start = tokPos;
+        var total = 0;
+        var e = len === void 0 ? Infinity : len;
+        for (var i = 0; i < e; ++i) {
+          var code = input.charCodeAt(tokPos),
+            val;
+          if (code >= 97) {
+            val = code - 97 + 10;
+          } else if (code >= 65) {
+            val = code - 65 + 10;
+          } else if (code >= 48 && code <= 57) {
+            val = code - 48;
+          } else {
+            val = Infinity;
+          }
+          if (val >= radix) break;
+          ++tokPos;
+          total = total * radix + val;
+        }
+        if (tokPos === start || len !== void 0 && tokPos - start !== len) {
+          return null;
+        }
+        return total;
+      }
+      function readHexNumber() {
+        tokPos += 2;
+        var val = readInt(16);
+        if (val === null) {
+          raise(tokStart + 2, "Expected hexadecimal number");
+        }
+        if (isIdentifierStart(input.charCodeAt(tokPos))) {
+          raise(tokPos, "Identifier directly after number");
+        }
+        finishToken(_num, val);
+      }
+      function readNumber(startsWithDot) {
+        var start = tokPos;
+        var isFloat = false;
+        var octal = input.charCodeAt(tokPos) === 48;
+        if (!startsWithDot && readInt(10) === null) {
+          raise(start, "Invalid number");
+        }
+        if (input.charCodeAt(tokPos) === 46) {
+          ++tokPos;
+          readInt(10);
+          isFloat = true;
+        }
+        var next2 = input.charCodeAt(tokPos);
+        if (next2 === 69 || next2 === 101) {
+          next2 = input.charCodeAt(++tokPos);
+          if (next2 === 43 || next2 === 45) {
+            ++tokPos;
+          }
+          if (readInt(10) === null) {
+            raise(start, "Invalid number");
+          }
+          isFloat = true;
+        }
+        if (isIdentifierStart(input.charCodeAt(tokPos))) {
+          raise(tokPos, "Identifier directly after number");
+        }
+        var str = input.slice(start, tokPos);
+        var val;
+        if (isFloat) {
+          val = parseFloat(str);
+        } else if (!octal || str.length === 1) {
+          val = parseInt(str, 10);
+        } else if (/[89]/.test(str) || strict) {
+          raise(start, "Invalid number");
+        } else {
+          val = parseInt(str, 8);
+        }
+        finishToken(_num, val);
+      }
+      function readString(quote) {
+        tokPos++;
+        var out = "";
+        for (;;) {
+          if (tokPos >= inputLen) raise(tokStart, "Unterminated string constant");
+          var ch = input.charCodeAt(tokPos);
+          if (ch === quote) {
+            ++tokPos;
+            finishToken(_string, out);
+            return;
+          }
+          if (ch === 92) {
+            ch = input.charCodeAt(++tokPos);
+            var octal = /^[0-7]+/.exec(input.slice(tokPos, tokPos + 3));
+            if (octal) {
+              octal = octal[0];
+            }
+            while (octal && parseInt(octal, 8) > 255) {
+              octal = octal.slice(0, -1);
+            }
+            if (octal === "0") {
+              octal = null;
+            }
+            ++tokPos;
+            if (octal) {
+              if (strict) raise(tokPos - 2, "Octal literal in strict mode");
+              out += String.fromCharCode(parseInt(octal, 8));
+              tokPos += octal.length - 1;
+            } else {
+              switch (ch) {
+                case 110:
+                  out += "\n";
+                  break;
+                case 114:
+                  out += "\r";
+                  break;
+                case 120:
+                  out += String.fromCharCode(readHexChar(2));
+                  break;
+                case 117:
+                  out += String.fromCharCode(readHexChar(4));
+                  break;
+                case 85:
+                  out += String.fromCharCode(readHexChar(8));
+                  break;
+                case 116:
+                  out += "	";
+                  break;
+                case 98:
+                  out += "\b";
+                  break;
+                case 118:
+                  out += "\v";
+                  break;
+                case 102:
+                  out += "\f";
+                  break;
+                case 48:
+                  out += "\0";
+                  break;
+                case 13:
+                  if (input.charCodeAt(tokPos) === 10) {
+                    ++tokPos;
+                  }
+                case 10:
+                  if (options.locations) {
+                    tokLineStart = tokPos;
+                    ++tokCurLine;
+                  }
+                  break;
+                default:
+                  out += String.fromCharCode(ch);
+                  break;
+              }
+            }
+          } else {
+            if (ch === 13 || ch === 10 || ch === 8232 || ch === 8233) {
+              raise(tokStart, "Unterminated string constant");
+            }
+            out += String.fromCharCode(ch);
+            ++tokPos;
+          }
+        }
+      }
+      function readHexChar(len) {
+        var n = readInt(16, len);
+        if (n === null) raise(tokStart, "Bad character escape sequence");
+        return n;
+      }
+      var containsEsc;
+      function readWord1() {
+        containsEsc = false;
+        var word;
+        var first = true;
+        var start = tokPos;
+        for (;;) {
+          var ch = input.charCodeAt(tokPos);
+          if (isIdentifierChar(ch)) {
+            if (containsEsc) {
+              word += input.charAt(tokPos);
+            }
+            ++tokPos;
+          } else if (ch === 92) {
+            if (!containsEsc) {
+              word = input.slice(start, tokPos);
+            }
+            containsEsc = true;
+            if (input.charCodeAt(++tokPos) !== 117) {
+              raise(tokPos, "Expecting Unicode escape sequence \\uXXXX");
+            }
+            ++tokPos;
+            var esc = readHexChar(4);
+            var escStr = String.fromCharCode(esc);
+            if (!escStr) raise(tokPos - 1, "Invalid Unicode escape");
+            if (!(first ? isIdentifierStart(esc) : isIdentifierChar(esc))) {
+              raise(tokPos - 4, "Invalid Unicode escape");
+            }
+            word += escStr;
+          } else {
+            break;
+          }
+          first = false;
+        }
+        return containsEsc ? word : input.slice(start, tokPos);
+      }
+      function readWord() {
+        var word = readWord1();
+        var type = _name;
+        if (!containsEsc && isKeyword(word)) {
+          type = keywordTypes[word];
+        }
+        finishToken(type, word);
+      }
+      function next() {
+        lastStart = tokStart;
+        lastEnd = tokEnd;
+        lastEndLoc = tokEndLoc;
+        readToken();
+      }
+      function setStrict(strct) {
+        strict = strct;
+        tokPos = tokStart;
+        if (options.locations) {
+          while (tokPos < tokLineStart) {
+            tokLineStart = input.lastIndexOf("\n", tokLineStart - 2) + 1;
+            --tokCurLine;
+          }
+        }
+        skipSpace();
+        readToken();
+      }
+      function node_t() {
+        this.type = null;
+        this.start = tokStart;
+        this.end = null;
+      }
+      function node_loc_t() {
+        this.start = tokStartLoc;
+        this.end = null;
+        if (sourceFile) {
+          this.source = sourceFile;
+        }
+      }
+      function startNode() {
+        var node = new node_t();
+        if (options.locations) {
+          node.loc = new node_loc_t();
+        }
+        if (options.directSourceFile) {
+          node.sourceFile = options.directSourceFile;
+        }
+        if (options.ranges) {
+          node.range = [tokStart, 0];
+        }
+        return node;
+      }
+      function startNodeFrom(other) {
+        var node = new node_t();
+        node.start = other.start;
+        if (options.locations) {
+          node.loc = new node_loc_t();
+          node.loc.start = other.loc.start;
+        }
+        if (options.ranges) {
+          node.range = [other.range[0], 0];
+        }
+        return node;
+      }
+      function finishNode(node, type) {
+        node.type = type;
+        node.end = lastEnd;
+        if (options.locations) {
+          node.loc.end = lastEndLoc;
+        }
+        if (options.ranges) {
+          node.range[1] = lastEnd;
+        }
+        return node;
+      }
+      function isUseStrict(stmt) {
+        return stmt.type === "ExpressionStatement" && stmt.expression.type === "Literal" && stmt.expression.value === "use strict";
+      }
+      function eat(type) {
+        if (tokType === type) {
+          next();
+          return true;
+        }
+        return false;
+      }
+      function canInsertSemicolon() {
+        return !options.strictSemicolons && (tokType === _eof || tokType === _braceR || newline.test(input.slice(lastEnd, tokStart)));
+      }
+      function semicolon() {
+        if (!eat(_semi) && !canInsertSemicolon()) {
+          unexpected();
+        }
+      }
+      function expect(type) {
+        if (tokType === type) {
+          next();
+        } else {
+          unexpected();
+        }
+      }
+      function unexpected() {
+        raise(tokStart, "Unexpected token");
+      }
+      function checkLVal(expr) {
+        if (expr.type !== "Identifier" && expr.type !== "MemberExpression") {
+          raise(expr.start, "Assigning to rvalue");
+        }
+        if (strict && expr.type === "Identifier" && isStrictBadIdWord(expr.name)) {
+          raise(expr.start, "Assigning to " + expr.name + " in strict mode");
+        }
+      }
+      function parseTopLevel(program) {
+        lastStart = lastEnd = tokPos;
+        if (options.locations) {
+          lastEndLoc = new line_loc_t();
+        }
+        inFunction = strict = false;
+        labels = [];
+        readToken();
+        var node = program || startNode();
+        var first = true;
+        if (!program) {
+          node.body = [];
+        }
+        while (tokType !== _eof) {
+          var stmt = parseStatement();
+          node.body.push(stmt);
+          if (first && isUseStrict(stmt)) {
+            setStrict(true);
+          }
+          first = false;
+        }
+        return finishNode(node, "Program");
+      }
+      var loopLabel = {
+        kind: "loop"
+      };
+      var switchLabel = {
+        kind: "switch"
+      };
+      function parseStatement() {
+        if (tokType === _slash || tokType === _assign && tokVal === "/=") {
+          readToken(true);
+        }
+        var starttype = tokType;
+        var node = startNode();
+        switch (starttype) {
+          case _break:
+          case _continue:
+            next();
+            var isBreak = starttype === _break;
+            if (eat(_semi) || canInsertSemicolon()) {
+              node.label = null;
+            } else if (tokType !== _name) {
+              unexpected();
+            } else {
+              node.label = parseIdent();
+              semicolon();
+            }
+            for (var i = 0; i < labels.length; ++i) {
+              var lab = labels[i];
+              if (node.label === null || lab.name === node.label.name) {
+                if (lab.kind !== null && (isBreak || lab.kind === "loop")) break;
+                if (node.label && isBreak) break;
+              }
+            }
+            if (i === labels.length) {
+              raise(node.start, "Unsyntactic " + starttype.keyword);
+            }
+            return finishNode(node, isBreak ? "BreakStatement" : "ContinueStatement");
+          case _debugger:
+            next();
+            semicolon();
+            return finishNode(node, "DebuggerStatement");
+          case _do:
+            next();
+            labels.push(loopLabel);
+            node.body = parseStatement();
+            labels.pop();
+            expect(_while);
+            node.test = parseParenExpression();
+            semicolon();
+            return finishNode(node, "DoWhileStatement");
+          case _for:
+            next();
+            labels.push(loopLabel);
+            expect(_parenL);
+            if (tokType === _semi) return parseFor(node, null);
+            if (tokType === _var) {
+              var init = startNode();
+              next();
+              parseVar(init, true);
+              finishNode(init, "VariableDeclaration");
+              if (init.declarations.length === 1 && eat(_in)) return parseForIn(node, init);
+              return parseFor(node, init);
+            }
+            var init = parseExpression(false, true);
+            if (eat(_in)) {
+              checkLVal(init);
+              return parseForIn(node, init);
+            }
+            return parseFor(node, init);
+          case _function:
+            next();
+            return parseFunction(node, true);
+          case _if:
+            next();
+            node.test = parseParenExpression();
+            node.consequent = parseStatement();
+            node.alternate = eat(_else) ? parseStatement() : null;
+            return finishNode(node, "IfStatement");
+          case _return:
+            if (!inFunction && !options.allowReturnOutsideFunction) {
+              raise(tokStart, "'return' outside of function");
+            }
+            next();
+            if (eat(_semi) || canInsertSemicolon()) {
+              node.argument = null;
+            } else {
+              node.argument = parseExpression();
+              semicolon();
+            }
+            return finishNode(node, "ReturnStatement");
+          case _switch:
+            next();
+            node.discriminant = parseParenExpression();
+            node.cases = [];
+            expect(_braceL);
+            labels.push(switchLabel);
+            for (var cur, sawDefault; tokType !== _braceR;) {
+              if (tokType === _case || tokType === _default) {
+                var isCase = tokType === _case;
+                if (cur) {
+                  finishNode(cur, "SwitchCase");
+                }
+                node.cases.push(cur = startNode());
+                cur.consequent = [];
+                next();
+                if (isCase) {
+                  cur.test = parseExpression();
+                } else {
+                  if (sawDefault) {
+                    raise(lastStart, "Multiple default clauses");
+                  }
+                  sawDefault = true;
+                  cur.test = null;
+                }
+                expect(_colon);
+              } else {
+                if (!cur) unexpected();
+                cur.consequent.push(parseStatement());
+              }
+            }
+            if (cur) finishNode(cur, "SwitchCase");
+            next();
+            labels.pop();
+            return finishNode(node, "SwitchStatement");
+          case _throw:
+            next();
+            if (newline.test(input.slice(lastEnd, tokStart))) raise(lastEnd, "Illegal newline after throw");
+            node.argument = parseExpression();
+            semicolon();
+            return finishNode(node, "ThrowStatement");
+          case _try:
+            next();
+            node.block = parseBlock();
+            node.handler = null;
+            if (tokType === _catch) {
+              var clause = startNode();
+              next();
+              expect(_parenL);
+              clause.param = parseIdent();
+              if (strict && isStrictBadIdWord(clause.param.name)) raise(clause.param.start, "Binding " + clause.param.name + " in strict mode");
+              expect(_parenR);
+              clause.body = parseBlock();
+              node.handler = finishNode(clause, "CatchClause");
+            }
+            node.finalizer = eat(_finally) ? parseBlock() : null;
+            if (!node.handler && !node.finalizer) raise(node.start, "Missing catch or finally clause");
+            return finishNode(node, "TryStatement");
+          case _var:
+            next();
+            parseVar(node);
+            semicolon();
+            return finishNode(node, "VariableDeclaration");
+          case _while:
+            next();
+            node.test = parseParenExpression();
+            labels.push(loopLabel);
+            node.body = parseStatement();
+            labels.pop();
+            return finishNode(node, "WhileStatement");
+          case _with:
+            if (strict) raise(tokStart, "'with' in strict mode");
+            next();
+            node.object = parseParenExpression();
+            node.body = parseStatement();
+            return finishNode(node, "WithStatement");
+          case _braceL:
+            return parseBlock();
+          case _semi:
+            next();
+            return finishNode(node, "EmptyStatement");
+          default:
+            var maybeName = tokVal;
+            var expr = parseExpression();
+            if (starttype === _name && expr.type === "Identifier" && eat(_colon)) {
+              for (var i = 0; i < labels.length; ++i) {
+                if (labels[i].name === maybeName) {
+                  raise(expr.start, "Label '" + maybeName + "' is already declared");
+                }
+              }
+              var kind = tokType.isLoop ? "loop" : tokType === _switch ? "switch" : null;
+              labels.push({
+                name: maybeName,
+                kind
+              });
+              node.body = parseStatement();
+              labels.pop();
+              node.label = expr;
+              return finishNode(node, "LabeledStatement");
+            } else {
+              node.expression = expr;
+              semicolon();
+              return finishNode(node, "ExpressionStatement");
+            }
+        }
+      }
+      function parseParenExpression() {
+        expect(_parenL);
+        var val = parseExpression();
+        expect(_parenR);
+        return val;
+      }
+      function parseBlock(allowStrict) {
+        var node = startNode();
+        var first = true;
+        var strict2 = false;
+        var oldStrict;
+        node.body = [];
+        expect(_braceL);
+        while (!eat(_braceR)) {
+          var stmt = parseStatement();
+          node.body.push(stmt);
+          if (first && allowStrict && isUseStrict(stmt)) {
+            oldStrict = strict2;
+            setStrict(strict2 = true);
+          }
+          first = false;
+        }
+        if (strict2 && !oldStrict) setStrict(false);
+        return finishNode(node, "BlockStatement");
+      }
+      function parseFor(node, init) {
+        node.init = init;
+        expect(_semi);
+        node.test = tokType === _semi ? null : parseExpression();
+        expect(_semi);
+        node.update = tokType === _parenR ? null : parseExpression();
+        expect(_parenR);
+        node.body = parseStatement();
+        labels.pop();
+        return finishNode(node, "ForStatement");
+      }
+      function parseForIn(node, init) {
+        node.left = init;
+        node.right = parseExpression();
+        expect(_parenR);
+        node.body = parseStatement();
+        labels.pop();
+        return finishNode(node, "ForInStatement");
+      }
+      function parseVar(node, noIn) {
+        node.declarations = [];
+        node.kind = "var";
+        for (;;) {
+          var decl = startNode();
+          decl.id = parseIdent();
+          if (strict && isStrictBadIdWord(decl.id.name)) raise(decl.id.start, "Binding " + decl.id.name + " in strict mode");
+          decl.init = eat(_eq) ? parseExpression(true, noIn) : null;
+          node.declarations.push(finishNode(decl, "VariableDeclarator"));
+          if (!eat(_comma)) break;
+        }
+      }
+      function parseExpression(noComma, noIn) {
+        var expr = parseMaybeAssign(noIn);
+        if (!noComma && tokType === _comma) {
+          var node = startNodeFrom(expr);
+          node.expressions = [expr];
+          while (eat(_comma)) node.expressions.push(parseMaybeAssign(noIn));
+          return finishNode(node, "SequenceExpression");
+        }
+        return expr;
+      }
+      function parseMaybeAssign(noIn) {
+        var left = parseMaybeConditional(noIn);
+        if (tokType.isAssign) {
+          var node = startNodeFrom(left);
+          node.operator = tokVal;
+          node.left = left;
+          next();
+          node.right = parseMaybeAssign(noIn);
+          checkLVal(left);
+          return finishNode(node, "AssignmentExpression");
+        }
+        return left;
+      }
+      function parseMaybeConditional(noIn) {
+        var expr = parseExprOps(noIn);
+        if (eat(_question)) {
+          var node = startNodeFrom(expr);
+          node.test = expr;
+          node.consequent = parseExpression(true);
+          expect(_colon);
+          node.alternate = parseExpression(true, noIn);
+          return finishNode(node, "ConditionalExpression");
+        }
+        return expr;
+      }
+      function parseExprOps(noIn) {
+        return parseExprOp(parseMaybeUnary(), -1, noIn);
+      }
+      function parseExprOp(left, minPrec, noIn) {
+        var prec = tokType.binop;
+        if (prec !== null && (!noIn || tokType !== _in)) {
+          if (prec > minPrec) {
+            var node = startNodeFrom(left);
+            node.left = left;
+            node.operator = tokVal;
+            var op = tokType;
+            next();
+            node.right = parseExprOp(parseMaybeUnary(), prec, noIn);
+            var exprNode = finishNode(node, op === _logicalOR || op === _logicalAND ? "LogicalExpression" : "BinaryExpression");
+            return parseExprOp(exprNode, minPrec, noIn);
+          }
+        }
+        return left;
+      }
+      function parseMaybeUnary() {
+        if (tokType.prefix) {
+          var node = startNode();
+          var update = tokType.isUpdate;
+          node.operator = tokVal;
+          node.prefix = true;
+          tokRegexpAllowed = true;
+          next();
+          node.argument = parseMaybeUnary();
+          if (update) checkLVal(node.argument);else if (strict && node.operator === "delete" && node.argument.type === "Identifier") raise(node.start, "Deleting local variable in strict mode");
+          return finishNode(node, update ? "UpdateExpression" : "UnaryExpression");
+        }
+        var expr = parseExprSubscripts();
+        while (tokType.postfix && !canInsertSemicolon()) {
+          var node = startNodeFrom(expr);
+          node.operator = tokVal;
+          node.prefix = false;
+          node.argument = expr;
+          checkLVal(expr);
+          next();
+          expr = finishNode(node, "UpdateExpression");
+        }
+        return expr;
+      }
+      function parseExprSubscripts() {
+        return parseSubscripts(parseExprAtom());
+      }
+      function parseSubscripts(base, noCalls) {
+        var node;
+        if (eat(_dot)) {
+          node = startNodeFrom(base);
+          node.object = base;
+          node.property = parseIdent(true);
+          node.computed = false;
+          return parseSubscripts(finishNode(node, "MemberExpression"), noCalls);
+        }
+        if (eat(_bracketL)) {
+          node = startNodeFrom(base);
+          node.object = base;
+          node.property = parseExpression();
+          node.computed = true;
+          expect(_bracketR);
+          return parseSubscripts(finishNode(node, "MemberExpression"), noCalls);
+        }
+        if (!noCalls && eat(_parenL)) {
+          node = startNodeFrom(base);
+          node.callee = base;
+          node.arguments = parseExprList(_parenR, false);
+          return parseSubscripts(finishNode(node, "CallExpression"), noCalls);
+        }
+        return base;
+      }
+      function parseExprAtom() {
+        var node;
+        switch (tokType) {
+          case _this:
+            node = startNode();
+            next();
+            return finishNode(node, "ThisExpression");
+          case _name:
+            return parseIdent();
+          case _num:
+          case _string:
+          case _regexp:
+            node = startNode();
+            node.value = tokVal;
+            node.raw = input.slice(tokStart, tokEnd);
+            next();
+            return finishNode(node, "Literal");
+          case _null:
+          case _true:
+          case _false:
+            node = startNode();
+            node.value = tokType.atomValue;
+            node.raw = tokType.keyword;
+            next();
+            return finishNode(node, "Literal");
+          case _parenL:
+            var tokStartLoc1 = tokStartLoc;
+            var tokStart1 = tokStart;
+            next();
+            var val = parseExpression();
+            val.start = tokStart1;
+            val.end = tokEnd;
+            if (options.locations) {
+              val.loc.start = tokStartLoc1;
+              val.loc.end = tokEndLoc;
+            }
+            if (options.ranges) {
+              val.range = [tokStart1, tokEnd];
+            }
+            expect(_parenR);
+            return val;
+          case _bracketL:
+            node = startNode();
+            next();
+            node.elements = parseExprList(_bracketR, true, true);
+            return finishNode(node, "ArrayExpression");
+          case _braceL:
+            return parseObj();
+          case _function:
+            node = startNode();
+            next();
+            return parseFunction(node, false);
+          case _new:
+            return parseNew();
+        }
+        unexpected();
+      }
+      function parseNew() {
+        var node = startNode();
+        next();
+        node.callee = parseSubscripts(parseExprAtom(), true);
+        node.arguments = eat(_parenL) ? parseExprList(_parenR, false) : empty;
+        return finishNode(node, "NewExpression");
+      }
+      function parseObj() {
+        var node = startNode();
+        var first = true;
+        var sawGetSet = false;
+        node.properties = [];
+        next();
+        while (!eat(_braceR)) {
+          if (!first) {
+            expect(_comma);
+            if (options.allowTrailingCommas && eat(_braceR)) {
+              break;
+            }
+          } else {
+            first = false;
+          }
+          var prop = {
+            key: parsePropertyName()
+          };
+          var isGetSet = false;
+          var kind;
+          if (eat(_colon)) {
+            prop.value = parseExpression(true);
+            kind = prop.kind = "init";
+          } else if (prop.key.type === "Identifier" && (prop.key.name === "get" || prop.key.name === "set")) {
+            isGetSet = sawGetSet = true;
+            kind = prop.kind = prop.key.name;
+            prop.key = parsePropertyName();
+            if (tokType !== _parenL) unexpected();
+            prop.value = parseFunction(startNode(), false);
+          } else {
+            unexpected();
+          }
+          if (prop.key.type === "Identifier" && (strict || sawGetSet)) {
+            for (var i = 0; i < node.properties.length; ++i) {
+              var other = node.properties[i];
+              if (other.key.name === prop.key.name) {
+                var conflict = kind === other.kind || isGetSet && other.kind === "init" || kind === "init" && (other.kind === "get" || other.kind === "set");
+                if (conflict && !strict && kind === "init" && other.kind === "init") {
+                  conflict = false;
+                }
+                if (conflict) {
+                  raise(prop.key.start, "Redefinition of property");
+                }
+              }
+            }
+          }
+          node.properties.push(prop);
+        }
+        return finishNode(node, "ObjectExpression");
+      }
+      function parsePropertyName() {
+        if (tokType === _num || tokType === _string) {
+          return parseExprAtom();
+        }
+        return parseIdent(true);
+      }
+      function parseFunction(node, isStatement) {
+        if (tokType === _name) {
+          node.id = parseIdent();
+        } else if (isStatement) {
+          unexpected();
+        } else {
+          node.id = null;
+        }
+        node.params = [];
+        var first = true;
+        expect(_parenL);
+        while (!eat(_parenR)) {
+          if (!first) {
+            expect(_comma);
+          } else {
+            first = false;
+          }
+          node.params.push(parseIdent());
+        }
+        var oldInFunc = inFunction;
+        var oldLabels = labels;
+        inFunction = true;
+        labels = [];
+        node.body = parseBlock(true);
+        inFunction = oldInFunc;
+        labels = oldLabels;
+        if (strict || node.body.body.length && isUseStrict(node.body.body[0])) {
+          for (var i = node.id ? -1 : 0; i < node.params.length; ++i) {
+            var id = i < 0 ? node.id : node.params[i];
+            if (isStrictReservedWord(id.name) || isStrictBadIdWord(id.name)) {
+              raise(id.start, "Defining '" + id.name + "' in strict mode");
+            }
+            if (i >= 0) {
+              for (var j = 0; j < i; ++j) {
+                if (id.name === node.params[j].name) {
+                  raise(id.start, "Argument name clash in strict mode");
+                }
+              }
+            }
+          }
+        }
+        return finishNode(node, isStatement ? "FunctionDeclaration" : "FunctionExpression");
+      }
+      function parseExprList(close, allowTrailingComma, allowEmpty) {
+        var elts = [];
+        var first = true;
+        while (!eat(close)) {
+          if (!first) {
+            expect(_comma);
+            if (allowTrailingComma && options.allowTrailingCommas && eat(close)) {
+              break;
+            }
+          } else {
+            first = false;
+          }
+          elts.push(allowEmpty && tokType === _comma ? null : parseExpression(true));
+        }
+        return elts;
+      }
+      function parseIdent(liberal) {
+        var node = startNode();
+        if (liberal && options.forbidReserved === "everywhere") {
+          liberal = false;
+        }
+        if (tokType === _name) {
+          if (!liberal && (options.forbidReserved && isReservedWord5(tokVal) || strict && isStrictReservedWord(tokVal)) && input.slice(tokStart, tokEnd).indexOf("\\") === -1) {
+            raise(tokStart, "The keyword '" + tokVal + "' is reserved");
+          }
+          node.name = tokVal;
+        } else if (liberal && tokType.keyword) {
+          node.name = tokType.keyword;
+        } else {
+          unexpected();
+        }
+        tokRegexpAllowed = false;
+        next();
+        return finishNode(node, "Identifier");
+      }
+    });
+  }
+});
+export default require_stdin()