{"version":3,"sources":["jsdelivr-header.js","/npm/@ts-jison/lexer-generator@0.4.1-alpha.2/lib/regexp-lexer.js"],"names":[],"mappings":"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","file":"/npm/@ts-jison/lexer-generator@0.4.1-alpha.2/lib/regexp-lexer.js","sourceRoot":"","sourcesContent":["/**\n * Minified by jsDelivr using Terser v5.39.0.\n * Original file: /npm/@ts-jison/lexer-generator@0.4.1-alpha.2/lib/regexp-lexer.js\n *\n * Do NOT use SRI with dynamically generated files! More information: https://www.jsdelivr.com/using-sri-with-dynamic-files\n */\n","// Basic Lexer implemented using JavaScript regular expressions\n// MIT Licensed\n\n\"use strict\";\n\nconst Fs = require('fs');\nconst Path = require('path');\nconst LexParser = new (require('@ts-jison/lex-parser').LexParser)();\nconst LexRegexpParser = new (require('@ts-jison/lex-parser/lib/lex-regexp-parser').LexRegexpParser)();\nconst {FileTemplate} = require('@ts-jison/common-generator');\nconst {RegexpAtom, Wildcard} = require('@ts-jison/lex-parser/lib/RegexpAtom');\nconst {RegexpAtomSubstitutionVisitor} = require('@ts-jison/lex-parser/lib/RegexpAtomSubstitutionVisitor');\nconst {RegexpAtomToJs} = require('@ts-jison/lex-parser/lib/RegexpAtomToStringVisitor');\nconst version = require('../package.json').version;\n\n// expand macros and convert matchers to RegExp's\nfunction prepareRules(rules, macros, actions, tokens, startConditions, caseless) {\n    var i,k,action,conditions,\n        newRules = [];\n\n    if (!macros) {\n        macros = {}\n    }\n\n    const noBreakIf = new RegExp(macros['no-break-if'] === undefined\n                                 ? '$.' // nothing can follow '$'\n                                 : macros['no-break-if'] === ''\n                                 ? '.*'\n                                 : '^(?:' + RegexpAtomToJs.serialize(macros['no-break-if'], 'simplifiy', false) + ')$');\n\n    function tokenNumberReplacement (str, token) {\n        return \"return \" + (tokens[token] || \"'\" + token + \"'\");\n    }\n\n    for (i=0;i < rules.length; i++) {\n        const curRule = rules[i];\n        if (!curRule.start) {\n            // implicit add to all inclusive start conditions\n            for (k in startConditions) {\n                if (startConditions[k].inclusive) {\n                    startConditions[k].rules.push(i);\n                }\n            }\n        } else if (curRule.start[0] === '*') {\n            // Add to ALL start conditions\n            for (k in startConditions) {\n                startConditions[k].rules.push(i);\n            }\n            // curRule.shift();\n        } else {\n            // Add to explicit start conditions\n            conditions = curRule.start;\n            for (k=0;k<conditions.length;k++) {\n                startConditions[conditions[k]].rules.push(i);\n            }\n        }\n\n        const pattern = RegexpAtomSubstitutionVisitor.substitute(curRule.pattern, macros)\n        const patternString = RegexpAtomToJs.serialize(pattern, 'simplify', true);\n        newRules.push(new RegExp(\"^(?:\" + patternString + \")\", caseless ? 'i':''));\n        if (typeof curRule.action === 'function') {\n            curRule.action = String(curRule.action) // function as a string\n                .replace(/^\\s*function\\s*\\(\\s*\\)\\s*{/, '') // strip 'function ( ) { ... }\n                .replace(/}\\s*$/, '');\n        }\n        action = curRule.action;\n        if (tokens && action.match(/return '[^']+'/)) {\n            action = action.replace(/return '([^']+)'/g, tokenNumberReplacement);\n        }\n\n        if (noBreakIf.test(action)) {\n            if ('verbose' in macros) {\n                console.log('not adding break because ', noBreakIf, 'matches', action);\n            }\n        } else {\n            if ('verbose' in macros) {\n                console.log('adding break because ', noBreakIf, 'does not match', action);\n            }\n            action = action + '\\n      break;';\n        }\n        actions.push('    case ' + i + ':' + action);\n    }\n\n    return newRules;\n}\n\nfunction prepareStartConditions (conditions) {\n    var sc,\n        hash = {};\n    for (sc in conditions) if (conditions.hasOwnProperty(sc)) {\n        hash[sc] = {rules:[],inclusive:!!!conditions[sc]};\n    }\n    return hash;\n}\n\nfunction buildActions (dict, tokens) {\n    var actions = [];\n    var tok;\n    var toks = {};\n\n    for (tok in tokens) {\n        toks[tokens[tok]] = tok;\n    }\n\n    if (dict.options && dict.options.flex) {\n        dict.rules.push({pattern: new Wildcard(), action: \"console.log(yytext);\"});\n    }\n\n    this.rules = prepareRules(dict.rules, dict.macros, actions, tokens && toks, this.conditions, this.options && this.options[\"case-insensitive\"]);\n    var fun = actions.join(\"\\n\");\n    \"yytext yyleng yylineno yylloc\".split(' ').forEach(function (yy) {\n        fun = fun.replace(new RegExp(\"\\\\b(\" + yy + \")\\\\b\", \"g\"), \"yy_.$1\");\n    });\n\n    return fun;\n}\n\nfunction RegExpLexer (dict, input, tokens, config = {}) {\n    var opts = processGrammar(dict, tokens);\n    var lexerText = generateModuleBody(opts, config.template);\n\n    if (config.makeGenerators) return {\n        generate: function () { return generateFromOpts(lexerText, opts); },\n        generateModule: function () { return generateModule(lexerText, opts) + \"return Lexer;\\n\"; },\n        generateModuleCore: function () { return generateModuleCore(lexerText, opts, ['Import', 'Constructor', 'Export']); },\n        generateCommonJSModule: function () { return generateCommonJSModule(lexerText, opts); },\n        generateAMDModule: function () { return generateAMDModule(lexerText, opts); },\n    };\n\n    const code = \"const [JisonLexer] = arguments;\\n\\n\"\n        + generateFromOpts(lexerText, Object.assign({bare: true}, opts)) + `return ${opts.moduleName || \"\"}Lexer;\\n`;\n    const { JisonLexer } = require('@ts-jison/lexer');\n    const ctor = new Function(code)(JisonLexer);\n    const lexer = new ctor();\n\n    if (input) {\n        lexer.setInput(input);\n    }\n    return lexer;\n}\n\n// generate lexer source from a grammar\nfunction generate (dict, tokens) {\n    var opt = processGrammar(dict, tokens);\n    var lexerText = generateModuleBody(opt, null);\n\n    return generateFromOpts(lexerText, opt) + \"return Lexer;\\n\";\n}\n\n/** Process the grammar and build final data structures and functions\n * jison CLI invokes with already parsed structures (i.e. with RegexpAtoms).\n * typical API use invokes with strings for macros and rule patterns\n * @param dict string | { dict?: Record<string | RegexpAtom>, rule: { pattern: RegexpAtom | string, action: string, ... } }\n * @param tokens Record<string: any> mapping to values returned by lexer\n * @returns basically a processed copy of the dict\n */\nfunction processGrammar(dict, tokens) {\n    var opts = {};\n    if (typeof dict === 'string') {\n        dict = LexParser.parse(dict);\n    } else {\n        if ('macros' in dict) {\n            for (const label in dict.macros)\n                if (typeof dict.macros[label] === 'string')\n                    dict.macros[label] = LexRegexpParser.parse(dict.macros[label]);\n        }\n        dict.rules.forEach(rule => {\n            if (typeof rule.pattern === 'string')\n                rule.pattern = LexRegexpParser.parse(rule.pattern);\n        })\n    }\n    dict = dict || {};\n\n    opts.options = dict.options || {};\n    opts.moduleType = opts.options.moduleType;\n    opts.moduleName = opts.options.moduleName;\n\n    opts.conditions = prepareStartConditions(dict.startConditions);\n    opts.conditions.INITIAL = {rules:[],inclusive:true};\n\n    opts.actionInclude = dict.actionInclude;\n    opts.performAction = buildActions.call(opts, dict, tokens);\n    opts.conditionStack = ['INITIAL'];\n\n    opts.moduleInclude = (dict.moduleInclude || '').trim();\n    return opts;\n}\n\n// Assemble the final source from the processed grammar\nfunction generateFromOpts (lexer, opt) {\n    var code = \"\";\n\n    if (opt.moduleType === 'commonjs') {\n        code = generateCommonJSModule(lexer, opt);\n    } else if (opt.moduleType === 'amd') {\n        code = generateAMDModule(lexer, opt);\n    } else {\n        code = generateModule(lexer, opt);\n    }\n\n    return code;\n}\n\nfunction generateModuleBody (opt, templateParm) {\n    const templatePath = Path.join(__dirname, '..', 'templates', (templateParm || 'javascript')) + '.yaml';\n    const template = new FileTemplate(templatePath, templatePath.endsWith(\".json\") ? FileTemplate.Format.JSON : FileTemplate.Format.YAML);\n\n    var strs = {EOF: \"1\", options:JSON.stringify(opt.options)};\n    const lexer = {strs, template};\n    if (opt.options) {\n        lexer.options = JSON.stringify(opt.options);\n    }\n\n    lexer.strs.performAction = String(opt.performAction);\n    lexer.strs.rules = \"[\\n\" + opt.rules.map(r => \"        \" + r).join(\",\\n\") + \"\\n    ]\";\n    lexer.strs.conditions = JSON.stringify(opt.conditions);\n    return lexer;\n}\n\nfunction generateModuleFunction(lexer, opt) {\n    return generateModuleCore(lexer, opt, ['Constructor']);\n}\nfunction generateModuleCore(lexer, opt, components) {\n    opt = opt || {};\n    var out = \"/* generated by @ts-jison/lexer-generator \" + version + \" */\\n\";\n\n    var templateParms = [\n        { token: \"NAME\", value: opt.moduleName || \"\"},\n        { token: \"OPTIONS\", value: JSON.stringify(opt.options) || \"{}\"},\n        { token: \"RULES\", value: lexer.strs.rules },\n        { token: \"CONDITIONS\", value: lexer.strs.conditions },\n        { token: \"ACTION_INCLUDE\", value: opt.actionInclude || '' },\n        { token: \"STATE_ACTIONS\", value: String(lexer.strs.performAction) },\n    ];\n    const moduleCode = components.map(k => lexer.template.substitute(k, templateParms)).join('\\n');\n    out += moduleCode;\n\n    if (opt.moduleInclude) {\n        out += \";\\n\" + opt.moduleInclude;\n    }\n\n    return out + \"\\n\";\n\n    function repl (s, token, value) {\n        var replaceMe = \"{{\" + token + \"}}\";\n        var start = s.indexOf(replaceMe);\n        if (start === -1)\n            throw Error(\"\\\"{{\" + token + \"}}\\\" not found in template string:\\n\" + s);\n        return s.substr(0, start) + value + s.substr(start+replaceMe.length);\n    }\n}\n\nfunction generateModule(lexer, opt) {\n    return generateModuleFunction(lexer, opt);\n}\n\nfunction generateAMDModule(lexer, opt) {\n    var moduleName = opt.moduleName || \"lexer\";\n    var out = \"/* generated by @ts-jison/lexer-generator \" + version + \" */\";\n\n    out += \"define([], \"\n        + generateModuleFunction(lexer, Object.assign({bare: true}, opt))\n        + \");\";\n\n    return out;\n}\n\nfunction generateCommonJSModule(lexer, opt) {\n    opt = opt || {};\n\n    var out = \"\";\n    var moduleName = opt.moduleName || \"Lexer\";\n\n    out += generateModule(lexer, opt);\n    out += \"\\nmodule.exports = \" + moduleName + \";\\n\";\n    return out;\n}\n\nRegExpLexer.generate = generate;\n\nmodule.exports = RegExpLexer;\n\n"]}