var jsl = typeof (jsl) === 'undefined' ? {} : jsl;
jsl.parser = function() {
    var a = !0
      , b = !1
      , c = {}
      , d = function() {
        var a = {
            trace: function() {},
            yy: {},
            symbols_: {
                error: 2,
                JSONString: 3,
                STRING: 4,
                JSONNumber: 5,
                NUMBER: 6,
                JSONNullLiteral: 7,
                NULL: 8,
                JSONBooleanLiteral: 9,
                TRUE: 10,
                FALSE: 11,
                JSONText: 12,
                JSONObject: 13,
                EOF: 14,
                JSONArray: 15,
                JSONValue: 16,
                "{": 17,
                "}": 18,
                JSONMemberList: 19,
                JSONMember: 20,
                ":": 21,
                ",": 22,
                "[": 23,
                "]": 24,
                JSONElementList: 25,
                $accept: 0,
                $end: 1
            },
            terminals_: {
                2: "error",
                4: "STRING",
                6: "NUMBER",
                8: "NULL",
                10: "TRUE",
                11: "FALSE",
                14: "EOF",
                17: "{",
                18: "}",
                21: ":",
                22: ",",
                23: "[",
                24: "]"
            },
            productions_: [0, [3, 1], [5, 1], [7, 1], [9, 1], [9, 1], [12, 2], [12, 2], [16, 1], [16, 1], [16, 1], [16, 1], [16, 1], [16, 1], [13, 2], [13, 3], [20, 3], [19, 1], [19, 3], [15, 2], [15, 3], [25, 1], [25, 3]],
            performAction: function(a, b, c, d, e, f, g) {
                var h = f.length - 1;
                switch (e) {
                case 1:
                    this.$ = a;
                    break;
                case 2:
                    this.$ = Number(a);
                    break;
                case 3:
                    this.$ = null ;
                    break;
                case 4:
                    this.$ = !0;
                    break;
                case 5:
                    this.$ = !1;
                    break;
                case 6:
                    return this.$ = f[h - 1];
                case 7:
                    return this.$ = f[h - 1];
                case 8:
                    this.$ = f[h];
                    break;
                case 9:
                    this.$ = f[h];
                    break;
                case 10:
                    this.$ = f[h];
                    break;
                case 11:
                    this.$ = f[h];
                    break;
                case 12:
                    this.$ = f[h];
                    break;
                case 13:
                    this.$ = f[h];
                    break;
                case 14:
                    this.$ = {};
                    break;
                case 15:
                    this.$ = f[h - 1];
                    break;
                case 16:
                    this.$ = [f[h - 2], f[h]];
                    break;
                case 17:
                    this.$ = {},
                    this.$[f[h][0]] = f[h][1];
                    break;
                case 18:
                    this.$ = f[h - 2],
                    f[h - 2][f[h][0]] = f[h][1];
                    break;
                case 19:
                    this.$ = [];
                    break;
                case 20:
                    this.$ = f[h - 1];
                    break;
                case 21:
                    this.$ = [f[h]];
                    break;
                case 22:
                    this.$ = f[h - 2],
                    f[h - 2].push(f[h])
                }
            },
            table: [{
                12: 1,
                13: 2,
                15: 3,
                17: [1, 4],
                23: [1, 5]
            }, {
                1: [3]
            }, {
                14: [1, 6]
            }, {
                14: [1, 7]
            }, {
                3: 11,
                4: [1, 12],
                18: [1, 8],
                19: 9,
                20: 10
            }, {
                3: 18,
                4: [1, 12],
                5: 19,
                6: [1, 25],
                7: 16,
                8: [1, 22],
                9: 17,
                10: [1, 23],
                11: [1, 24],
                13: 20,
                15: 21,
                16: 15,
                17: [1, 4],
                23: [1, 5],
                24: [1, 13],
                25: 14
            }, {
                1: [2, 6]
            }, {
                1: [2, 7]
            }, {
                14: [2, 14],
                18: [2, 14],
                22: [2, 14],
                24: [2, 14]
            }, {
                18: [1, 26],
                22: [1, 27]
            }, {
                18: [2, 17],
                22: [2, 17]
            }, {
                21: [1, 28]
            }, {
                18: [2, 1],
                21: [2, 1],
                22: [2, 1],
                24: [2, 1]
            }, {
                14: [2, 19],
                18: [2, 19],
                22: [2, 19],
                24: [2, 19]
            }, {
                22: [1, 30],
                24: [1, 29]
            }, {
                22: [2, 21],
                24: [2, 21]
            }, {
                18: [2, 8],
                22: [2, 8],
                24: [2, 8]
            }, {
                18: [2, 9],
                22: [2, 9],
                24: [2, 9]
            }, {
                18: [2, 10],
                22: [2, 10],
                24: [2, 10]
            }, {
                18: [2, 11],
                22: [2, 11],
                24: [2, 11]
            }, {
                18: [2, 12],
                22: [2, 12],
                24: [2, 12]
            }, {
                18: [2, 13],
                22: [2, 13],
                24: [2, 13]
            }, {
                18: [2, 3],
                22: [2, 3],
                24: [2, 3]
            }, {
                18: [2, 4],
                22: [2, 4],
                24: [2, 4]
            }, {
                18: [2, 5],
                22: [2, 5],
                24: [2, 5]
            }, {
                18: [2, 2],
                22: [2, 2],
                24: [2, 2]
            }, {
                14: [2, 15],
                18: [2, 15],
                22: [2, 15],
                24: [2, 15]
            }, {
                3: 11,
                4: [1, 12],
                20: 31
            }, {
                3: 18,
                4: [1, 12],
                5: 19,
                6: [1, 25],
                7: 16,
                8: [1, 22],
                9: 17,
                10: [1, 23],
                11: [1, 24],
                13: 20,
                15: 21,
                16: 32,
                17: [1, 4],
                23: [1, 5]
            }, {
                14: [2, 20],
                18: [2, 20],
                22: [2, 20],
                24: [2, 20]
            }, {
                3: 18,
                4: [1, 12],
                5: 19,
                6: [1, 25],
                7: 16,
                8: [1, 22],
                9: 17,
                10: [1, 23],
                11: [1, 24],
                13: 20,
                15: 21,
                16: 33,
                17: [1, 4],
                23: [1, 5]
            }, {
                18: [2, 18],
                22: [2, 18]
            }, {
                18: [2, 16],
                22: [2, 16]
            }, {
                22: [2, 22],
                24: [2, 22]
            }],
            defaultActions: {
                6: [2, 6],
                7: [2, 7]
            },
            parseError: function(a, b) {
                throw new Error(a)
            },
            parse: function(a) {
                function o() {
                    var a;
                    a = b.lexer.lex() || 1,
                    typeof a != "number" && (a = b.symbols_[a] || a);
                    return a
                }
                function n(a) {
                    c.length = c.length - 2 * a,
                    d.length = d.length - a,
                    e.length = e.length - a
                }
                var b = this
                  , c = [0]
                  , d = [null ]
                  , e = []
                  , f = this.table
                  , g = ""
                  , h = 0
                  , i = 0
                  , j = 0
                  , k = 2
                  , l = 1;
                this.lexer.setInput(a),
                this.lexer.yy = this.yy,
                this.yy.lexer = this.lexer,
                typeof this.lexer.yylloc == "undefined" && (this.lexer.yylloc = {});
                var m = this.lexer.yylloc;
                e.push(m),
                typeof this.yy.parseError == "function" && (this.parseError = this.yy.parseError);
                var p, q, r, s, t, u, v = {}, w, x, y, z;
                for (; ; ) {
                    r = c[c.length - 1],
                    this.defaultActions[r] ? s = this.defaultActions[r] : (p == null  && (p = o()),
                    s = f[r] && f[r][p]);
                    if (typeof s == "undefined" || !s.length || !s[0]) {
                        if (!j) {
                            z = [];
                            for (w in f[r])
                                this.terminals_[w] && w > 2 && z.push("'" + this.terminals_[w] + "'");
                            var A = "";
                            this.lexer.showPosition ? A = "Parse error on line " + (h + 1) + ":\n" + this.lexer.showPosition() + "\nExpecting " + z.join(", ") : A = "Parse error on line " + (h + 1) + ": Unexpected " + (p == 1 ? "end of input" : "'" + (this.terminals_[p] || p) + "'"),
                            this.parseError(A, {
                                text: this.lexer.match,
                                token: this.terminals_[p] || p,
                                line: this.lexer.yylineno,
                                loc: m,
                                expected: z
                            })
                        }
                        if (j == 3) {
                            if (p == l)
                                throw new Error(A || "Parsing halted.");
                            i = this.lexer.yyleng,
                            g = this.lexer.yytext,
                            h = this.lexer.yylineno,
                            m = this.lexer.yylloc,
                            p = o()
                        }
                        for (; ; ) {
                            if (k.toString() in f[r])
                                break;
                            if (r == 0)
                                throw new Error(A || "Parsing halted.");
                            n(1),
                            r = c[c.length - 1]
                        }
                        q = p,
                        p = k,
                        r = c[c.length - 1],
                        s = f[r] && f[r][k],
                        j = 3
                    }
                    if (s[0] instanceof Array && s.length > 1)
                        throw new Error("Parse Error: multiple actions possible at state: " + r + ", token: " + p);
                    switch (s[0]) {
                    case 1:
                        c.push(p),
                        d.push(this.lexer.yytext),
                        e.push(this.lexer.yylloc),
                        c.push(s[1]),
                        p = null ,
                        q ? (p = q,
                        q = null ) : (i = this.lexer.yyleng,
                        g = this.lexer.yytext,
                        h = this.lexer.yylineno,
                        m = this.lexer.yylloc,
                        j > 0 && j--);
                        break;
                    case 2:
                        x = this.productions_[s[1]][1],
                        v.$ = d[d.length - x],
                        v._$ = {
                            first_line: e[e.length - (x || 1)].first_line,
                            last_line: e[e.length - 1].last_line,
                            first_column: e[e.length - (x || 1)].first_column,
                            last_column: e[e.length - 1].last_column
                        },
                        u = this.performAction.call(v, g, i, h, this.yy, s[1], d, e);
                        if (typeof u != "undefined")
                            return u;
                        x && (c = c.slice(0, -1 * x * 2),
                        d = d.slice(0, -1 * x),
                        e = e.slice(0, -1 * x)),
                        c.push(this.productions_[s[1]][0]),
                        d.push(v.$),
                        e.push(v._$),
                        y = f[c[c.length - 2]][c[c.length - 1]],
                        c.push(y);
                        break;
                    case 3:
                        return !0
                    }
                }
                return !0
            }
        }
          , f = function() {
            var a = {
                EOF: 1,
                parseError: function(a, b) {
                    if (this.yy.parseError)
                        this.yy.parseError(a, b);
                    else
                        throw new Error(a)
                },
                setInput: function(a) {
                    this._input = a,
                    this._more = this._less = this.done = !1,
                    this.yylineno = this.yyleng = 0,
                    this.yytext = this.matched = this.match = "",
                    this.conditionStack = ["INITIAL"],
                    this.yylloc = {
                        first_line: 1,
                        first_column: 0,
                        last_line: 1,
                        last_column: 0
                    };
                    return this
                },
                input: function() {
                    var a = this._input[0];
                    this.yytext += a,
                    this.yyleng++,
                    this.match += a,
                    this.matched += a;
                    var b = a.match(/\n/);
                    b && this.yylineno++,
                    this._input = this._input.slice(1);
                    return a
                },
                unput: function(a) {
                    this._input = a + this._input;
                    return this
                },
                more: function() {
                    this._more = !0;
                    return this
                },
                pastInput: function() {
                    var a = this.matched.substr(0, this.matched.length - this.match.length);
                    return (a.length > 20 ? "..." : "") + a.substr(-20).replace(/\n/g, "")
                },
                upcomingInput: function() {
                    var a = this.match;
                    a.length < 20 && (a += this._input.substr(0, 20 - a.length));
                    return (a.substr(0, 20) + (a.length > 20 ? "..." : "")).replace(/\n/g, "")
                },
                showPosition: function() {
                    var a = this.pastInput()
                      , b = Array(a.length + 1).join("-");
                    return a + this.upcomingInput() + "\n" + b + "^"
                },
                next: function() {
                    if (this.done)
                        return this.EOF;
                    this._input || (this.done = !0);
                    var a, b, c, d;
                    this._more || (this.yytext = "",
                    this.match = "");
                    var e = this._currentRules();
                    for (var f = 0; f < e.length; f++) {
                        b = this._input.match(this.rules[e[f]]);
                        if (b) {
                            d = b[0].match(/\n.*/g),
                            d && (this.yylineno += d.length),
                            this.yylloc = {
                                first_line: this.yylloc.last_line,
                                last_line: this.yylineno + 1,
                                first_column: this.yylloc.last_column,
                                last_column: d ? d[d.length - 1].length - 1 : this.yylloc.last_column + b[0].length
                            },
                            this.yytext += b[0],
                            this.match += b[0],
                            this.matches = b,
                            this.yyleng = this.yytext.length,
                            this._more = !1,
                            this._input = this._input.slice(b[0].length),
                            this.matched += b[0],
                            a = this.performAction.call(this, this.yy, this, e[f], this.conditionStack[this.conditionStack.length - 1]);
                            if (a)
                                return a;
                            return
                        }
                    }
                    if (this._input === "")
                        return this.EOF;
                    this.parseError("Lexical error on line " + (this.yylineno + 1) + ". Unrecognized text.\n" + this.showPosition(), {
                        text: "",
                        token: null ,
                        line: this.yylineno
                    })
                },
                lex: function() {
                    var a = this.next();
                    return typeof a != "undefined" ? a : this.lex()
                },
                begin: function(a) {
                    this.conditionStack.push(a)
                },
                popState: function() {
                    return this.conditionStack.pop()
                },
                _currentRules: function() {
                    return this.conditions[this.conditionStack[this.conditionStack.length - 1]].rules
                }
            };
            a.performAction = function(a, b, c, d) {
                var e = d;
                switch (c) {
                case 0:
                    break;
                case 1:
                    return 6;
                case 2:
                    b.yytext = b.yytext.substr(1, b.yyleng - 2);
                    return 4;
                case 3:
                    return 17;
                case 4:
                    return 18;
                case 5:
                    return 23;
                case 6:
                    return 24;
                case 7:
                    return 22;
                case 8:
                    return 21;
                case 9:
                    return 10;
                case 10:
                    return 11;
                case 11:
                    return 8;
                case 12:
                    return 14;
                case 13:
                    return "INVALID"
                }
            }
            ,
            a.rules = [/^\s+/, /^-?([0-9]|[1-9][0-9]+)(\.[0-9]+)?([eE][-+]?[0-9]+)?\b/, /^"(\\["bfnrt/\\]|\\u[a-fA-F0-9]{4}|[^\0-\x09\x0a-\x1f"\\])*"/, /^\{/, /^\}/, /^\[/, /^\]/, /^,/, /^:/, /^true\b/, /^false\b/, /^null\b/, /^$/, /^./],
            a.conditions = {
                INITIAL: {
                    rules: [0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13],
                    inclusive: !0
                }
            };
            return a
        }();
        a.lexer = f;
        return a
    }();
    typeof a != "undefined" && typeof c != "undefined" && (c.parser = d,
    c.parse = function() {
        return d.parse.apply(d, arguments)
    }
    ,
    c.main = function(b) {
        if (!b[1])
            throw new Error("Usage: " + b[0] + " FILE");
        if (typeof process != "undefined")
            var d = a("fs").readFileSync(a("path").join(process.cwd(), b[1]), "utf8");
        else
            var e = a("file").path(a("file").cwd())
              , d = e.join(b[1]).read({
                charset: "utf-8"
            });
        return c.parser.parse(d)
    }
    ,
    typeof b != "undefined" && a.main === b && c.main(typeof process != "undefined" ? process.argv.slice(1) : a("system").args));
    return c
}();
//format
var jsl = typeof jsl === 'undefined' ? {} : jsl;
jsl.format = (function() {
    function repeat(s, count) {
        return new Array(count + 1).join(s)
    }
    function formatJson(json) {
        var i = 0
          , il = 0
          , tab = "    "
          , newJson = ""
          , indentLevel = 0
          , inString = false
          , currentChar = null ;
        for (i = 0,
        il = json.length; i < il; i += 1) {
            currentChar = json.charAt(i);
            switch (currentChar) {
            case '{':
            case '[':
                if (!inString) {
                    newJson += currentChar + "\n" + repeat(tab, indentLevel + 1);
                    indentLevel += 1
                } else {
                    newJson += currentChar
                }
                break;
            case '}':
            case ']':
                if (!inString) {
                    indentLevel -= 1;
                    newJson += "\n" + repeat(tab, indentLevel) + currentChar
                } else {
                    newJson += currentChar
                }
                break;
            case ',':
                if (!inString) {
                    newJson += ",\n" + repeat(tab, indentLevel)
                } else {
                    newJson += currentChar
                }
                break;
            case ':':
                if (!inString) {
                    newJson += ": "
                } else {
                    newJson += currentChar
                }
                break;
            case ' ':
            case "\n":
            case "\t":
                if (inString) {
                    newJson += currentChar
                }
                break;
            case '"':
                if (i > 0 && json.charAt(i - 1) !== '\\') {
                    inString = !inString
                }
                newJson += currentChar;
                break;
            default:
                newJson += currentChar;
                break
            }
        }
        return newJson
    }
    return {
        "formatJson": formatJson
    }
}());
export default jsl;