{"version":3,"sources":["jsdelivr-header.js","/npm/@rokucommunity/brs@0.47.4/lib/index.js"],"names":[],"mappings":"AAAA;AACA;AACA;AACA;AACA;AACA;AACA,ACNA,aACA,IAAI,gBAAmB,MAAQ,KAAK,kBAAqB,OAAO,OAAS,SAAU,EAAG,EAAG,EAAG,QAC7E,IAAP,IAAkB,EAAK,GAC3B,IAAI,EAAO,OAAO,yBAAyB,EAAG,GACzC,KAAS,QAAS,GAAQ,EAAE,WAAa,EAAK,UAAY,EAAK,gBAClE,EAAO,CAAE,YAAY,EAAM,IAAK,WAAa,OAAO,EAAE,EAAI,IAE5D,OAAO,eAAe,EAAG,EAAI,EAChC,EAAI,SAAU,EAAG,EAAG,EAAG,QACT,IAAP,IAAkB,EAAK,GAC3B,EAAE,GAAM,EAAE,EACb,GACG,mBAAsB,MAAQ,KAAK,qBAAwB,OAAO,OAAS,SAAU,EAAG,GACxF,OAAO,eAAe,EAAG,UAAW,CAAE,YAAY,EAAM,MAAO,GAClE,EAAI,SAAS,EAAG,GACb,EAAW,QAAI,CACnB,GACI,aAAgB,MAAQ,KAAK,cAAiB,WAC9C,IAAI,EAAU,SAAS,GAMnB,OALA,EAAU,OAAO,qBAAuB,SAAU,GAC9C,IAAI,EAAK,GACT,IAAK,IAAI,KAAK,EAAO,OAAO,UAAU,eAAe,KAAK,EAAG,KAAI,EAAG,EAAG,QAAU,GACjF,OAAO,CACX,EACO,EAAQ,EACnB,EACA,OAAO,SAAU,GACb,GAAI,GAAO,EAAI,WAAY,OAAO,EAClC,IAAI,EAAS,CAAC,EACd,GAAW,MAAP,EAAa,IAAK,IAAI,EAAI,EAAQ,GAAM,EAAI,EAAG,EAAI,EAAE,OAAQ,IAAkB,YAAT,EAAE,IAAkB,gBAAgB,EAAQ,EAAK,EAAE,IAE7H,OADA,mBAAmB,EAAQ,GACpB,CACX,CACH,CAhBiD,GAiB9C,gBAAmB,MAAQ,KAAK,iBAAoB,SAAU,GAC9D,OAAQ,GAAO,EAAI,WAAc,EAAM,CAAE,QAAW,EACxD,EACA,OAAO,eAAe,QAAS,aAAc,CAAE,OAAO,IACtD,QAAQ,OAAS,QAAQ,aAAe,QAAQ,MAAQ,QAAQ,WAAQ,EACxE,QAAQ,QAAU,QAClB,QAAQ,mBAAqB,mBAC7B,QAAQ,aAAe,aACvB,QAAQ,uBAAyB,uBACjC,QAAQ,KAAO,KACf,MAAM,GAAK,aAAa,QAAQ,OAC1B,SAAW,aAAa,QAAQ,aAChC,QAAU,gBAAgB,QAAQ,UAClC,OAAS,QAAQ,QACjB,SAAU,EAAI,OAAO,WAAW,GAAG,SACnC,aAAe,gBAAgB,QAAQ,eACvC,oBAAsB,gBAAgB,QAAQ,sBAC9C,QAAU,QAAQ,WAClB,GAAK,aAAa,QAAQ,mBAChC,QAAQ,aAAe,GACvB,MAAM,aAAe,QAAQ,gBACvB,SAAW,QAAQ,YACnB,cAAgB,QAAQ,iBACxB,aAAe,QAAQ,gBACvB,SAAW,aAAa,QAAQ,YAChC,YAAc,aAAa,QAAQ,kBACnC,WAAa,QAAQ,cACrB,SAAW,QAAQ,YACnB,OAAS,aAAa,QAAQ,YACpC,QAAQ,MAAQ,OAChB,MAAM,SAAW,aAAa,QAAQ,eACtC,QAAQ,MAAQ,SAChB,MAAM,QAAU,aAAa,QAAQ,aACrC,QAAQ,OAAS,QACjB,MAAM,MAAQ,QAAQ,OAChB,KAAO,aAAa,QAAQ,SAC5B,WAAa,gBAAgB,QAAQ,aACrC,KAAO,gBAAgB,QAAQ,OAC/B,cAAgB,QAAQ,6BAC9B,IAAI,kBAAoB,KAYxB,eAAe,QAAQ,EAAW,GAC9B,IAAI,cAAE,EAAa,YAAE,SAAsB,UAAU,GACjD,EAAU,IAAI,MAClB,EAAU,SAAS,IACf,EAAQ,KAAK,CAAE,KAAM,oBAAqB,IAAK,GAAO,IAE1D,IAAI,QAAuB,EAAc,GACzC,OAAO,EAAY,KAAK,EAC5B,CACA,eAAe,UAAU,GACrB,MAAM,EAAmB,OAAO,OAAO,OAAO,OAAO,CAAC,EAAG,cAAc,yBAA0B,GACjG,IAAI,QAAiB,GAAG,YAAY,EAAiB,MACjD,EAAmB,EAAQ,mBACzB,EAAS,IAAI,mCACb,EACN,GAAgC,kBAArB,EACP,MAAM,IAAI,MAAM,mFAEf,GAAI,EAAQ,oBAA0C,MAApB,EACnC,MAAM,IAAI,MAAM,0FAEpB,IAAI,QAA6B,EAAI,aAAa,2BAA2B,EAAiB,KAAM,EAAiB,cAAe,GAChI,EAAqB,MAAM,KAAK,EAAqB,UACpD,KAAK,IAAc,CACpB,YACA,UAAW,EAAU,SAAS,QAAQ,GAAuC,qBAA7B,EAAM,KAAK,oBAE1D,QAAO,EAAG,eAAgB,GAAa,EAAU,OAAS,IAC3D,EAA0B,IAAI,IAC9B,EAA2B,GAC/B,IAAK,IAAI,UAAE,EAAS,UAAE,KAAe,EACjC,IAAK,IAAI,KAAM,EAAW,CACtB,IAAI,EAAM,EAAG,OAAO,IACpB,IAAK,EACD,SAEJ,GAAI,EAAI,WAAW,YAAc,EAAI,WAAW,YAAa,CACzD,EAAiB,OAAO,MAAM,0EAA0E,QACxG,QACJ,CACA,IAAI,EAAY,EAAiB,KAAK,QAAQ,WAAY,KAAK,MAAM,KACjE,EAAY,EAAU,QAAQ,QAAQ,WAAY,KAAK,MAAM,KACxC,UAArB,QAAQ,WACR,EAAY,EAAU,QAAQ,aAAc,IAC5C,EAAY,EAAU,QAAQ,aAAc,KAEhD,IAAI,EAAa,IAAI,MAAM,IAAI,EAAK,QAAQ,KAAK,MAAM,SAAS,EAAW,MAAc,WACzF,GAAI,EAAwB,IAAI,GAC5B,SAEJ,IAAI,GAAe,EAAI,oBAAoB,SAAS,GAChD,QAAgB,QAAQ,KAAK,KAAK,KAAK,QAAQ,SAAU,OAAO,KAAiB,QACrF,EAAwB,IAAI,EAAY,GACxC,IAAI,EAAgB,KAAK,KAAK,EAAiB,KAAM,IAAI,MAAM,IAAI,GAAK,UACxE,EAAyB,MAAK,EAAI,aAAa,SAAS,EAAe,GAAS,MAAK,IAAM,UAAU,OAAO,OAAO,OAAO,OAAO,CAAC,EAAG,GAAU,CAAE,KAAM,EAAS,cAAe,GAAI,oBAAoB,OAC3M,CAEJ,EAAqB,SAAS,IAC1B,KAAI,EAAU,QAAQ,OAAS,GAE/B,IACI,EAAU,QAAU,EAAU,QAAQ,KAAK,IACnC,EAAO,MACP,EAAO,IAAM,KAAK,KAAK,EAAiB,KAAM,IAAI,MAAM,IAAI,EAAO,KAAK,WAErE,IAEf,CACA,MAAO,GACH,MAAM,IAAI,MAAM,+CAA+C,EAAU,SAAS,IACtF,KAEJ,MAAM,QAAoB,cAAc,YAAY,0BAA0B,EAAsB,EAAU,GAC9G,IAAK,EACD,MAAM,IAAI,MAAM,gCAGpB,EAAY,SAAW,EACvB,IAAI,SAAsC,EAAI,WAAW,SAAS,IAC7D,QAAQ,GAAW,EAAO,cAC1B,KAAK,GAAW,EAAO,MAAM,cAClC,EAAY,yBAAyB,SAC/B,EAAI,SAAS,sBAAsB,EAAa,EAAiB,MACvE,IAAI,EAAgB,YAAY,iBAAiB,EAAU,GAM3D,OALI,EAAiB,mBACjB,kBAAoB,IAAI,WAAW,kBAAkB,EAAiB,KAAM,SACtE,kBAAkB,gBACxB,EAAY,qBAAqB,oBAE9B,CAAE,gBAAe,cAC5B,CAIA,SAAS,qBACL,GAAK,kBAEL,OAAO,kBAAkB,aAC7B,CAUA,SAAS,aAAa,EAAW,GAC7B,MAAM,EAAmB,OAAO,OAAO,OAAO,OAAO,CAAC,EAAG,cAAc,yBAA0B,GACjG,IAAI,EAAW,GAAG,gBAAgB,EAAiB,MACnD,OAAO,EACF,KAAK,IACN,IAAI,EAAQ,IAAI,QAAQ,MACpB,EAAe,IAAI,GAAG,aACtB,EAAS,IAAI,SAAS,OAC1B,CAAC,EAAO,EAAc,GAAQ,SAAS,GAAY,EAAQ,QAAQ,SAAS,eAAe,EAAiB,WAC5G,IAAI,EAAW,GAAG,aAAa,EAAU,QACrC,EAAc,EAAM,KAAK,EAAU,GACnC,EAAsB,EAAa,WAAW,EAAY,OAAQ,GAClE,EAAe,EAAO,MAAM,EAAoB,iBACpD,GAAI,EAAa,OAAO,OAAS,EAC7B,KAAM,yBAEV,OAAO,EAAa,UAAU,IAE7B,QAAO,CAAC,EAAe,IAAe,IAAI,KAAkB,IAAa,GAClF,CASA,eAAe,uBAAuB,EAAmB,GACrD,IAAI,cAAE,EAAa,YAAE,SAAsB,UAAU,GACjD,EAAU,IAAI,MAClB,EAAkB,SAAS,IACvB,EAAQ,KAAK,CAAE,KAAM,oBAAqB,IAAK,GAAO,IAE1D,IAAI,QAAuB,EAAc,GAIzC,OAHA,EAAY,KAAK,GAEjB,EAAY,OAAS,GACd,CAAC,EAAW,KAEf,EAAY,YAAY,cACxB,EAAI,aAAa,iBACjB,IAAI,EAAM,aAAa,EAAW,EAAY,SAC1C,EAAa,GACb,EAAc,EAAY,UAAU,IACpC,IAAI,EAAQ,EAAe,KAAK,KAAQ,GAAM,IAAM,SAAS,WAAW,SAGxE,OAFA,EAAa,EAAe,OAC5B,EAAe,OAAS,GACjB,CAAK,IAIhB,GAAI,EAAW,OACX,MAAM,EAEV,OAAO,CAAW,CAE1B,CAOA,SAAS,OACL,MAAM,EAAkB,IAAI,cAAc,YAC1C,EAAgB,QAAQ,SAAS,eAAe,QAAQ,SACxD,MAAM,EAAK,SAAS,gBAAgB,CAChC,MAAO,QAAQ,MACf,OAAQ,QAAQ,SAEpB,EAAG,UAAU,GAAG,QAAQ,QAAQ,QAAQ,YACxC,EAAG,GAAG,QAAS,IACX,IAAI,EAAI,EAAI,EACZ,MAAM,EAAM,EAAK,OAAO,cACxB,GAAI,CAAC,OAAQ,OAAQ,KAAK,SAAS,GAC/B,QAAQ,WAEP,IAAI,CAAC,MAAO,SAAS,SAAS,GAG/B,OAFA,QAAQ,OAAO,MAAM,WACrB,EAAG,SAGF,GAAI,CAAC,OAAQ,QAAQ,SAAS,GAG/B,OAFA,iBACA,EAAG,SAGF,GAAI,CAAC,MAAO,QAAQ,SAAuC,QAA7B,EAAK,EAAK,MAAM,KAAK,UAAuB,IAAP,OAAgB,EAAS,EAAG,cAAc,QAAS,CACvH,MAAM,EAA8G,QAAjG,EAAmC,QAA7B,EAAK,EAAK,MAAM,KAAK,UAAuB,IAAP,OAAgB,EAAS,EAAG,cAAc,cAA2B,IAAP,EAAgB,EAAK,WACjJ,IAAI,EAAQ,cAAc,MAAM,SAchC,MAbkB,WAAd,GACA,EAAQ,cAAc,MAAM,OAC5B,QAAQ,IAAI,QAAQ,QAAQ,WAAW,+BAEpB,WAAd,GACL,EAAQ,cAAc,MAAM,OAC5B,QAAQ,IAAI,QAAQ,QAAQ,WAAW,+BAGvC,QAAQ,IAAI,QAAQ,QAAQ,WAAW,6BAE3C,QAAQ,IAAI,QAAQ,QAAQ,WAAW,EAAgB,gBAAgB,UACvE,EAAG,QAEP,EACA,IAAI,EAAU,IAAI,EAAM,cAAc,wBAAyB,GAC3D,GACA,EAAQ,KAAK,IACL,IAAW,SAAS,WAAW,UAC/B,QAAQ,KAAI,EAAI,cAAc,UAAU,EAAO,YACnD,IAGR,EAAG,QAAQ,IAEf,QAAQ,KAAI,EAAI,cAAc,UAAU,4DACxC,EAAG,QACP,CAYA,SAAS,IAAI,EAAU,EAAU,cAAc,wBAAyB,GACpE,MAAM,EAAQ,IAAI,QAAQ,MACpB,EAAS,IAAI,SAAS,OACtB,EAAa,SAAS,eAAe,EAAQ,QACnD,EAAM,QAAQ,GACd,EAAO,QAAQ,GACf,MAAM,EAAc,EAAM,KAAK,EAAU,QACzC,GAAI,EAAY,OAAO,OAAS,EAC5B,OAEJ,MAAM,EAAe,EAAO,MAAM,EAAY,QAC9C,KAAI,EAAa,OAAO,OAAS,IAGM,IAAnC,EAAa,WAAW,OAG5B,IACI,OAAO,EAAY,KAAK,EAAa,WACzC,CACA,MAAO,GAEH,MACJ,CACJ,CAIA,SAAS,YACL,IAAI,EAAU,OACd,GAAW,yBACX,GAAW,8DACX,GAAW,oEACX,GAAW,uDACX,GAAW,iDACX,GAAW,sDACX,GAAW,4EACX,QAAQ,IAAI,QAAQ,QAAQ,WAD5B,wXAEJ","file":"/npm/@rokucommunity/brs@0.47.4/lib/index.js","sourceRoot":"","sourcesContent":["/**\n * Minified by jsDelivr using Terser v5.39.0.\n * Original file: /npm/@rokucommunity/brs@0.47.4/lib/index.js\n *\n * Do NOT use SRI with dynamically generated files! More information: https://www.jsdelivr.com/using-sri-with-dynamic-files\n */\n","\"use strict\";\nvar __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {\n    if (k2 === undefined) k2 = k;\n    var desc = Object.getOwnPropertyDescriptor(m, k);\n    if (!desc || (\"get\" in desc ? !m.__esModule : desc.writable || desc.configurable)) {\n      desc = { enumerable: true, get: function() { return m[k]; } };\n    }\n    Object.defineProperty(o, k2, desc);\n}) : (function(o, m, k, k2) {\n    if (k2 === undefined) k2 = k;\n    o[k2] = m[k];\n}));\nvar __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {\n    Object.defineProperty(o, \"default\", { enumerable: true, value: v });\n}) : function(o, v) {\n    o[\"default\"] = v;\n});\nvar __importStar = (this && this.__importStar) || (function () {\n    var ownKeys = function(o) {\n        ownKeys = Object.getOwnPropertyNames || function (o) {\n            var ar = [];\n            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;\n            return ar;\n        };\n        return ownKeys(o);\n    };\n    return function (mod) {\n        if (mod && mod.__esModule) return mod;\n        var result = {};\n        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== \"default\") __createBinding(result, mod, k[i]);\n        __setModuleDefault(result, mod);\n        return result;\n    };\n})();\nvar __importDefault = (this && this.__importDefault) || function (mod) {\n    return (mod && mod.__esModule) ? mod : { \"default\": mod };\n};\nObject.defineProperty(exports, \"__esModule\", { value: true });\nexports.parser = exports.preprocessor = exports.types = exports.lexer = void 0;\nexports.execute = execute;\nexports.getCoverageResults = getCoverageResults;\nexports.lexParseSync = lexParseSync;\nexports.createExecuteWithScope = createExecuteWithScope;\nexports.repl = repl;\nconst fs = __importStar(require(\"fs\"));\nconst readline = __importStar(require(\"readline\"));\nconst chalk_1 = __importDefault(require(\"chalk\"));\nconst util_1 = require(\"util\");\nconst mkdtemp = (0, util_1.promisify)(fs.mkdtemp);\nconst decompress_1 = __importDefault(require(\"decompress\"));\nconst sanitize_filename_1 = __importDefault(require(\"sanitize-filename\"));\nconst lexer_1 = require(\"./lexer\");\nconst PP = __importStar(require(\"./preprocessor\"));\nexports.preprocessor = PP;\nconst scenegraph_1 = require(\"./scenegraph\");\nconst parser_1 = require(\"./parser\");\nconst interpreter_1 = require(\"./interpreter\");\nconst extensions_1 = require(\"./extensions\");\nconst BrsError = __importStar(require(\"./Error\"));\nconst LexerParser = __importStar(require(\"./LexerParser\"));\nconst coverage_1 = require(\"./coverage\");\nconst stdlib_1 = require(\"./stdlib\");\nconst _lexer = __importStar(require(\"./lexer\"));\nexports.lexer = _lexer;\nconst BrsTypes = __importStar(require(\"./brsTypes\"));\nexports.types = BrsTypes;\nconst _parser = __importStar(require(\"./parser\"));\nexports.parser = _parser;\nconst url_1 = require(\"url\");\nconst path = __importStar(require(\"path\"));\nconst p_settle_1 = __importDefault(require(\"p-settle\"));\nconst os_1 = __importDefault(require(\"os\"));\nconst Environment_1 = require(\"./interpreter/Environment\");\nlet coverageCollector = null;\n/**\n * Executes a BrightScript file by path and writes its output to the streams\n * provided in `options`.\n *\n * @param filename the absolute path to the `.brs` file to be executed\n * @param options configuration for the execution, including the streams to use for `stdout` and\n *                `stderr` and the base directory for path resolution\n *\n * @returns a `Promise` that will be resolve if `filename` is successfully\n *          executed, or be rejected if an error occurs.\n */\nasync function execute(filenames, options) {\n    let { lexerParserFn, interpreter } = await loadFiles(options);\n    let scripts = new Array();\n    filenames.forEach((file) => {\n        scripts.push({ type: \"text/brightscript\", uri: file });\n    });\n    let mainStatements = await lexerParserFn(scripts);\n    return interpreter.exec(mainStatements);\n}\nasync function loadFiles(options) {\n    const executionOptions = Object.assign(Object.assign({}, interpreter_1.defaultExecutionOptions), options);\n    let manifest = await PP.getManifest(executionOptions.root);\n    let maybeLibraryName = options.isComponentLibrary\n        ? manifest.get(\"sg_component_libs_provided\")\n        : undefined;\n    if (typeof maybeLibraryName === \"boolean\") {\n        throw new Error(\"Encountered invalid boolean value for manifest key 'sg_component_libs_provided'\");\n    }\n    else if (options.isComponentLibrary && maybeLibraryName == null) {\n        throw new Error(\"Could not find required manifest key 'sg_component_libs_provided' in component library\");\n    }\n    let componentDefinitions = await (0, scenegraph_1.getComponentDefinitionMap)(executionOptions.root, executionOptions.componentDirs, maybeLibraryName);\n    let componentLibraries = Array.from(componentDefinitions.values())\n        .map((component) => ({\n        component,\n        libraries: component.children.filter((child) => child.name.toLowerCase() === \"componentlibrary\"),\n    }))\n        .filter(({ libraries }) => libraries && libraries.length > 0);\n    let knownComponentLibraries = new Map();\n    let componentLibrariesToLoad = [];\n    for (let { component, libraries } of componentLibraries) {\n        for (let cl of libraries) {\n            let uri = cl.fields.uri;\n            if (!uri) {\n                continue;\n            }\n            if (uri.startsWith(\"http://\") || uri.startsWith(\"https://\")) {\n                executionOptions.stderr.write(`WARNING: Only pkg:/-local component libraries are supported; ignoring '${uri}'\\n`);\n                continue;\n            }\n            let posixRoot = executionOptions.root.replace(/[\\/\\\\]+/g, path.posix.sep);\n            let posixPath = component.xmlPath.replace(/[\\/\\\\]+/g, path.posix.sep);\n            if (process.platform === \"win32\") {\n                posixRoot = posixRoot.replace(/^[a-zA-Z]:/, \"\");\n                posixPath = posixPath.replace(/^[a-zA-Z]:/, \"\");\n            }\n            let packageUri = new url_1.URL(uri, `pkg:/${path.posix.relative(posixRoot, posixPath)}`).toString();\n            if (knownComponentLibraries.has(packageUri)) {\n                continue;\n            }\n            let sanitizedUri = (0, sanitize_filename_1.default)(packageUri);\n            let tempdir = await mkdtemp(path.join(os_1.default.tmpdir(), `brs-${sanitizedUri}`), \"utf8\");\n            knownComponentLibraries.set(packageUri, tempdir);\n            let zipFileOnDisk = path.join(executionOptions.root, new url_1.URL(uri).pathname);\n            componentLibrariesToLoad.push((0, decompress_1.default)(zipFileOnDisk, tempdir).then(() => loadFiles(Object.assign(Object.assign({}, options), { root: tempdir, componentDirs: [], isComponentLibrary: true }))));\n        }\n    }\n    componentDefinitions.forEach((component) => {\n        if (component.scripts.length < 1)\n            return;\n        try {\n            component.scripts = component.scripts.map((script) => {\n                if (script.uri) {\n                    script.uri = path.join(executionOptions.root, new url_1.URL(script.uri).pathname);\n                }\n                return script;\n            });\n        }\n        catch (error) {\n            throw new Error(`Encountered an error when parsing component ${component.name}: ${error}`);\n        }\n    });\n    const interpreter = await interpreter_1.Interpreter.withSubEnvsFromComponents(componentDefinitions, manifest, executionOptions);\n    if (!interpreter) {\n        throw new Error(\"Unable to build interpreter.\");\n    }\n    // Store manifest as a property on the Interpreter for further reusing\n    interpreter.manifest = manifest;\n    let componentLibraryInterpreters = (await (0, p_settle_1.default)(componentLibrariesToLoad))\n        .filter((result) => result.isFulfilled)\n        .map((result) => result.value.interpreter);\n    interpreter.mergeNodeDefinitionsWith(componentLibraryInterpreters);\n    await (0, stdlib_1.loadTranslationFiles)(interpreter, executionOptions.root);\n    let lexerParserFn = LexerParser.getLexerParserFn(manifest, options);\n    if (executionOptions.generateCoverage) {\n        coverageCollector = new coverage_1.CoverageCollector(executionOptions.root, lexerParserFn);\n        await coverageCollector.crawlBrsFiles();\n        interpreter.setCoverageCollector(coverageCollector);\n    }\n    return { lexerParserFn, interpreter };\n}\n/**\n * Returns a summary of the code coverage.\n */\nfunction getCoverageResults() {\n    if (!coverageCollector)\n        return;\n    return coverageCollector.getCoverage();\n}\n/**\n * A synchronous version of the lexer-parser flow.\n *\n * @param filename the paths to BrightScript files to lex and parse synchronously\n * @param options configuration for the execution, including the streams to use for `stdout` and\n *                `stderr` and the base directory for path resolution\n *\n * @returns the AST produced from lexing and parsing the provided files\n */\nfunction lexParseSync(filenames, options) {\n    const executionOptions = Object.assign(Object.assign({}, interpreter_1.defaultExecutionOptions), options);\n    let manifest = PP.getManifestSync(executionOptions.root);\n    return filenames\n        .map((filename) => {\n        let lexer = new lexer_1.Lexer();\n        let preprocessor = new PP.Preprocessor();\n        let parser = new parser_1.Parser();\n        [lexer, preprocessor, parser].forEach((emitter) => emitter.onError(BrsError.getLoggerUsing(executionOptions.stderr)));\n        let contents = fs.readFileSync(filename, \"utf8\");\n        let scanResults = lexer.scan(contents, filename);\n        let preprocessorResults = preprocessor.preprocess(scanResults.tokens, manifest);\n        let parseResults = parser.parse(preprocessorResults.processedTokens);\n        if (parseResults.errors.length > 0) {\n            throw \"Error occurred parsing\";\n        }\n        return parseResults.statements;\n    })\n        .reduce((allStatements, statements) => [...allStatements, ...statements], []);\n}\n/**\n * Runs a set of files to create an execution scope, and generates an execution function that runs in that scope.\n *\n * @param filenamesForScope List of filenames to put into the execution scope\n * @param options Execution options\n *\n * @returns A function to execute files using the created scope.\n */\nasync function createExecuteWithScope(filenamesForScope, options) {\n    let { lexerParserFn, interpreter } = await loadFiles(options);\n    let scripts = new Array();\n    filenamesForScope.forEach((file) => {\n        scripts.push({ type: \"text/brightscript\", uri: file });\n    });\n    let mainStatements = await lexerParserFn(scripts);\n    interpreter.exec(mainStatements);\n    // Clear any errors that accumulated, so that we can isolate errors from future calls to the execute function.\n    interpreter.errors = [];\n    return (filenames, args) => {\n        // Reset any mocks so that subsequent executions don't interfere with each other.\n        interpreter.environment.resetMocks();\n        (0, extensions_1.resetTestData)();\n        let ast = lexParseSync(filenames, interpreter.options);\n        let execErrors = [];\n        let returnValue = interpreter.inSubEnv((subInterpreter) => {\n            let value = subInterpreter.exec(ast, ...args)[0] || BrsTypes.BrsInvalid.Instance;\n            execErrors = subInterpreter.errors;\n            subInterpreter.errors = [];\n            return value;\n        });\n        // Re-throw any errors the interpreter encounters. We can't throw them directly from the `inSubEnv` call,\n        // because they get caught by upstream handlers.\n        if (execErrors.length) {\n            throw execErrors;\n        }\n        return returnValue;\n    };\n}\n/**\n * Launches an interactive read-execute-print loop, which reads input from\n * `stdin` and executes it.\n *\n * **NOTE:** Currently limited to single-line inputs :(\n */\nfunction repl() {\n    const replInterpreter = new interpreter_1.Interpreter();\n    replInterpreter.onError(BrsError.getLoggerUsing(process.stderr));\n    const rl = readline.createInterface({\n        input: process.stdin,\n        output: process.stdout,\n    });\n    rl.setPrompt(`${chalk_1.default.magenta(\"brs\")}> `);\n    rl.on(\"line\", (line) => {\n        var _a, _b, _c;\n        const cmd = line.trim().toLowerCase();\n        if ([\"quit\", \"exit\", \"q\"].includes(cmd)) {\n            process.exit();\n        }\n        else if ([\"cls\", \"clear\"].includes(cmd)) {\n            process.stdout.write(\"\\x1Bc\");\n            rl.prompt();\n            return;\n        }\n        else if ([\"help\", \"hint\"].includes(cmd)) {\n            printHelp();\n            rl.prompt();\n            return;\n        }\n        else if ([\"var\", \"vars\"].includes((_a = line.split(\" \")[0]) === null || _a === void 0 ? void 0 : _a.toLowerCase().trim())) {\n            const scopeName = (_c = (_b = line.split(\" \")[1]) === null || _b === void 0 ? void 0 : _b.toLowerCase().trim()) !== null && _c !== void 0 ? _c : \"function\";\n            let scope = Environment_1.Scope.Function;\n            if (scopeName === \"global\") {\n                scope = Environment_1.Scope.Global;\n                console.log(chalk_1.default.cyanBright(`\\r\\nGlobal variables:\\r\\n`));\n            }\n            else if (scopeName === \"module\") {\n                scope = Environment_1.Scope.Module;\n                console.log(chalk_1.default.cyanBright(`\\r\\nModule variables:\\r\\n`));\n            }\n            else {\n                console.log(chalk_1.default.cyanBright(`\\r\\nLocal variables:\\r\\n`));\n            }\n            console.log(chalk_1.default.cyanBright(replInterpreter.formatVariables(scope)));\n            rl.prompt();\n            return;\n        }\n        let results = run(line, interpreter_1.defaultExecutionOptions, replInterpreter);\n        if (results) {\n            results.map((result) => {\n                if (result !== BrsTypes.BrsInvalid.Instance) {\n                    console.log((0, interpreter_1.colorize)(result.toString()));\n                }\n            });\n        }\n        rl.prompt();\n    });\n    console.log((0, interpreter_1.colorize)(\"type `help` to see the list of valid REPL commands.\\r\\n\"));\n    rl.prompt();\n}\n/**\n * Runs an arbitrary string of BrightScript code.\n * @param contents the BrightScript code to lex, parse, and interpret.\n * @param options the streams to use for `stdout` and `stderr`. Mostly used for\n *                testing.\n * @param interpreter an interpreter to use when executing `contents`. Required\n *                    for `repl` to have persistent state between user inputs.\n * @returns an array of statement execution results, indicating why each\n *          statement exited and what its return value was, or `undefined` if\n *          `interpreter` threw an Error.\n */\nfunction run(contents, options = interpreter_1.defaultExecutionOptions, interpreter) {\n    const lexer = new lexer_1.Lexer();\n    const parser = new parser_1.Parser();\n    const logErrorFn = BrsError.getLoggerUsing(options.stderr);\n    lexer.onError(logErrorFn);\n    parser.onError(logErrorFn);\n    const scanResults = lexer.scan(contents, \"REPL\");\n    if (scanResults.errors.length > 0) {\n        return;\n    }\n    const parseResults = parser.parse(scanResults.tokens);\n    if (parseResults.errors.length > 0) {\n        return;\n    }\n    if (parseResults.statements.length === 0) {\n        return;\n    }\n    try {\n        return interpreter.exec(parseResults.statements);\n    }\n    catch (e) {\n        //options.stderr.write(e.message);\n        return;\n    }\n}\n/**\n * Display the help message on the console.\n */\nfunction printHelp() {\n    let helpMsg = \"\\r\\n\";\n    helpMsg += \"REPL Command List:\\r\\n\";\n    helpMsg += \"   print|?           Print variable value or expression\\r\\n\";\n    helpMsg += \"   var|vars [scope]  Display variables and their types/values\\r\\n\";\n    helpMsg += \"   help|hint         Show this REPL command list\\r\\n\";\n    helpMsg += \"   clear|cls         Clear terminal screen\\r\\n\";\n    helpMsg += \"   exit|quit|q       Terminate REPL session\\r\\n\\r\\n\";\n    helpMsg += \"   Type any valid BrightScript expression for a live compile and run.\\r\\n\";\n    console.log(chalk_1.default.cyanBright(helpMsg));\n}\n"]}