{"version":3,"sources":["jsdelivr-header.js","/npm/vsl-nearley@2.9.5/lib/nearley.js"],"names":[],"mappings":"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","file":"/npm/vsl-nearley@2.9.5/lib/nearley.js","sourceRoot":"","sourcesContent":["/**\n * Minified by jsDelivr using Terser v5.39.0.\n * Original file: /npm/vsl-nearley@2.9.5/lib/nearley.js\n *\n * Do NOT use SRI with dynamically generated files! More information: https://www.jsdelivr.com/using-sri-with-dynamic-files\n */\n","(function(root, factory) {\n    if (typeof module === 'object' && module.exports) {\n        module.exports = factory();\n    } else {\n        root.nearley = factory();\n    }\n}(this, function() {\n\nfunction Rule(exp, grammar, symbols, postprocess) {\n    this.exp = exp;\n    this.grammar = grammar;\n    this.symbols = symbols; // a list of literal | regex class | nonterminal\n    this.postprocess = postprocess;\n    return this;\n}\n\nRule.prototype.toString = function(withCursorAt) {\n    var self = this;\n    function stringifySymbolSequence (e) {\n        var type = typeof e;\n        return type === \"string\" ? JSON.stringify(e) :\n            type === \"number\" ? self.grammar.names[e] :\n            e.type ? \"%\" + e.type : e.toString();\n    }\n    var symbolSequence = typeof withCursorAt === \"undefined\" ?\n        this.symbols.map(stringifySymbolSequence).join(' ') :\n        (\n            this.symbols.slice(0, withCursorAt).map(stringifySymbolSequence).join(' ') +\n            \" ● \" +\n            this.symbols.slice(withCursorAt).map(stringifySymbolSequence).join(' ')\n        );\n    return this.grammar.names[this.exp] + \" → \" + symbolSequence;\n};\n\n\n// a State is a rule at a position from a given starting point in the input stream (reference)\nfunction State(rule, dot, reference, location, wantedBy) {\n    this.rule = rule;\n    this.dot = dot;\n    this.reference = reference;\n    this.location = location;\n    this.data = [];\n    this.wantedBy = wantedBy;\n    this.isComplete = this.dot === rule.symbols.length;\n}\n\nState.prototype.toString = function() {\n    return \"{\" + this.rule.toString(this.dot) + \"}, from: \" + (this.reference || 0);\n};\n\nState.prototype.nextState = function(child, location) {\n    var state = new State(this.rule, this.dot + 1, this.reference, location, this.wantedBy);\n    state.left = this;\n    state.right = child;\n    if (state.isComplete)\n        state.data = state.build();\n    return state;\n};\n\nState.prototype.build = function() {\n    var children = [],\n        node = this;\n    do {\n        children.push(node.right.data);\n        node = node.left;\n    } while (node.left);\n    children.reverse();\n    return children;\n};\n\nState.prototype.finish = function() {\n    if (this.rule.postprocess) {\n        this.data = this.rule.postprocess(this.data, this.location, Parser.fail);\n    }\n};\n\n\nfunction Column(grammar, index, location) {\n    this.grammar = grammar;\n    this.index = index;\n    this.location = location;\n    this.states = [];\n    this.wants = []; // states indexed by the non-terminal they expect\n    this.scannable = []; // list of states that expect a token\n    this.completed = []; // states that are nullable\n}\n\n\nColumn.prototype.process = function(nextColumn) {\n    var states = this.states,\n        wants = this.wants,\n        completed = this.completed,\n        exp;\n\n    for (var w = 0; w < states.length; w++) { // nb. we push() during iteration\n        var state = states[w];\n\n        if (state.isComplete) {\n            state.finish();\n            if (state.data !== Parser.fail) {\n                // complete\n                var wantedBy = state.wantedBy;\n                for (var i = wantedBy.length; i--; ) { // this line is hot\n                    this.complete(wantedBy[i], state);\n                }\n\n                // special-case nullables\n                if (state.reference === this.index) {\n                    // make sure future predictors of this rule get completed.\n                    exp = state.rule.exp;\n                    (completed[exp] = completed[exp] || []).push(state);\n                }\n            }\n        } else {\n            // queue scannable states\n            exp = state.rule.symbols[state.dot];\n            if (typeof exp !== 'number') {\n                this.scannable.push(state);\n                continue;\n            }\n\n            // predict\n            if (wants[exp]) {\n                wants[exp].push(state);\n\n                if (completed[exp]) {\n                    var nulls = completed[exp];\n                    for (var i = 0; i < nulls.length; i++) {\n                        this.complete(state, nulls[i]);\n                    }\n                }\n            } else {\n                wants[exp] = [state];\n                this.predict(exp);\n            }\n        }\n    }\n};\n\nColumn.prototype.predict = function(exp) {\n    var rules = this.grammar.rules[exp] || [];\n\n    for (var i = 0; i < rules.length; i++) {\n        this.states.push(new State(rules[i], 0, this.index, this.location, this.wants[exp]));\n    }\n};\n\nColumn.prototype.complete = function(left, right) {\n    if (left.rule.symbols[left.dot] === right.rule.exp) {\n        this.states.push(left.nextState(right, right.location));\n    }\n};\n\n\nfunction Grammar(rules) {\n    this.rules = rules;\n}\n\n// So we can allow passing (rules) directly to Parser for backwards compatibility\nGrammar.fromCompiled = function(rules, names) {\n    var lexer = rules.Lexer;\n    var g = new Grammar(rules.map(function (ruleSet, i) {\n        return ruleSet.map(function (rule) {\n            return new Rule(i, g, rule[0], rule[1]);\n        });\n    }));\n    g.names = names;\n    g.lexer = lexer; // nb. storing lexer on Grammar is iffy, but unavoidable\n    return g;\n};\n\n\nfunction StreamLexer() {\n    this.reset(\"\");\n}\n\nStreamLexer.prototype.reset = function(data, state) {\n    this.buffer = data;\n    this.index = 0;\n    this.line = state ? state.line : 1;\n    this.lastLineBreak = state ? -state.col : 0;\n};\n\nStreamLexer.prototype.next = function() {\n    if (this.index < this.buffer.length) {\n        var ch = this.buffer[this.index++];\n        if (ch === \"\\n\") {\n          this.line += 1;\n          this.lastLineBreak = this.index;\n        }\n        return {value: ch};\n    }\n};\n\nStreamLexer.prototype.save = function() {\n    return {\n        line: this.line,\n        col: this.index - this.lastLineBreak,\n    };\n};\n\nStreamLexer.prototype.formatError = function(token, message) {\n    // nb. this gets called after consuming the offending token,\n    // so the culprit is index-1\n    var buffer = this.buffer;\n    if (typeof buffer === 'string') {\n        var nextLineBreak = buffer.indexOf('\\n', this.index);\n        if (nextLineBreak === -1) {\n            nextLineBreak = buffer.length;\n        }\n        var line = buffer.substring(this.lastLineBreak, nextLineBreak);\n        var col = this.index - this.lastLineBreak;\n        message += \" at line \" + this.line + \" col \" + col + \":\\n\\n\";\n            + \"  \" + line + \"\\n\"\n            + \"  \" + Array(col).join(\" \") + \"^\";\n        return message;\n    } else {\n        return message + \" at index \" + (this.index - 1);\n    }\n};\n\n\nfunction Parser(rules, names, options) {\n    var grammar;\n    if (rules instanceof Grammar) {\n        grammar = this.grammar = rules;\n        options = names;\n    } else {\n        grammar = this.grammar = Grammar.fromCompiled(rules, names);\n    }\n    \n    this.start = grammar.rules[0];\n\n    // Read options\n    this.options = {\n        keepHistory: false,\n        lexer: grammar.lexer || new StreamLexer(),\n    };\n\n    for (var key in (options || {})) {\n        this.options[key] = options[key];\n    }\n\n    // Setup lexer\n    this.lexer = this.options.lexer;\n    this.lexerState = undefined;\n\n    // Setup a table\n    var column = new Column(grammar, 0);\n    this.table = [column];\n\n    // I could be expecting anything.\n    column.wants[0] = [];\n    column.predict(0);\n    // TODO what if start rule is nullable?\n    column.process();\n    this.current = 0; // token index\n    \n    this.tokens = 0; // tokens consumed\n}\n\n// create a reserved token for indicating a parse fail\nParser.fail = {};\n\n//TODO: change to work with new rules table\nParser.prototype.feed = function(chunk) {\n    var n,\n        lexer = this.lexer,\n        token,\n        latest = lexer.latest ?\n            lexer.latest.bind(lexer) :\n            function () { return n; };\n    lexer.reset(chunk, this.lexerState);\n\n    while ((token = lexer.next())) {\n        this.tokens++;\n        // We add new states to table[current+1]\n        var column = this.table[this.current];\n\n        // GC unused states\n        if (!this.options.keepHistory) {\n            delete this.table[this.current - 1];\n        }\n\n        var n = this.current + 1,\n            location = latest(),\n            nextColumn = new Column(this.grammar, n, location);\n        this.table.push(nextColumn);\n\n        // Advance all tokens that expect the symbol\n        var literal = token.value,\n            value = lexer.constructor === StreamLexer ? token.value : token,\n            scannable = column.scannable;\n        for (var w = scannable.length; w--; ) {\n            var state = scannable[w];\n            var expect = state.rule.symbols[state.dot];\n            // Try to consume the token, either regex or literal\n            if (expect.test ? expect.test(value) :\n                expect.type ? expect.type === token.type\n                            : expect === literal) {\n                // Add it\n                var next = state.nextState({data: value, token: token, isToken: true}, location);\n                nextColumn.states.push(next);\n            }\n        }\n        // TODO: make it only process things once if same state and same index if faster - somebody\n\n        // Next, for each of the rules, we either\n        // (a) complete it, and try to see if the reference row expected that\n        //     rule\n        // (b) predict the next nonterminal it expects by adding that\n        //     nonterminal's start state\n        // To prevent duplication, we also keep track of rules we have already\n        // added\n\n        nextColumn.process();\n\n        // If needed, throw an error:\n        if (nextColumn.states.length === 0) {\n            // No states at all! This is not good.\n            var message = this.lexer.formatError(token, \"invalid syntax\") + \"\\n\";\n            message += \"Unexpected \" + (token.type ? token.type + \" token: \" : \"\");\n            message += JSON.stringify(typeof token.value !== \"undefined\" ? token.value : token) + \"\\n\";\n            var err = new Error(message);\n            err.offset = this.current;\n            throw err;\n        }\n\n        // maybe save lexer state\n        if (this.options.keepHistory) {\n            column.lexerState = lexer.save();\n        }\n\n        this.current++;\n    }\n    if (column) {\n        this.lexerState = lexer.save();\n    }\n\n    // Incrementally keep track of results\n    this.results = this.finish();\n\n    // Allow chaining, for whatever it's worth\n    return this;\n};\n\nParser.prototype.save = function() {\n    var column = this.table[this.current];\n    column.lexerState = this.lexerState;\n    return column;\n};\n\nParser.prototype.restore = function(column) {\n    var index = column.index;\n    this.current = index;\n    this.table[index] = column;\n    this.table.splice(index + 1);\n    this.lexerState = column.lexerState;\n\n    // Incrementally keep track of results\n    this.results = this.finish();\n};\n\n// nb. deprecated: use save/restore instead!\nParser.prototype.rewind = function(index) {\n    if (!this.options.keepHistory) {\n        throw new Error('set option `keepHistory` to enable rewinding');\n    }\n    // nb. recall column (table) indicies fall between token indicies.\n    //        col 0   --   token 0   --   col 1\n    this.restore(this.table[index]);\n};\n\nParser.prototype.finish = function() {\n    // Return the possible parsings\n    var considerations = [],\n        column = this.table[this.table.length - 1];\n    var self = this;\n    column.states.forEach(function (t) {\n        if (self.start.indexOf(t.rule) !== -1\n            && t.dot === t.rule.symbols.length\n            && t.reference === 0\n            && t.data !== Parser.fail\n        ) {\n            considerations.push(t);\n        }\n    });\n    var result = considerations.map(function(c) {return c.data; });\n    result.tokens = this.tokens;\n    return result;\n};\n\nreturn {\n    Parser: Parser,\n    Grammar: Grammar,\n    Rule: Rule,\n};\n\n}));\n"]}