@eagleoutice/flowr 1.5.1 → 2.0.0

package/cli/flowr.d.ts

@@ -0,0 +1,29 @@
+import type { OptionDefinition } from 'command-line-usage';
+export declare const toolName = "flowr";
+export declare const optionDefinitions: OptionDefinition[];
+export interface FlowrCliOptions {
+    verbose: boolean;
+    version: boolean;
+    help: boolean;
+    server: boolean;
+    ws: boolean;
+    port: number;
+    'no-ansi': boolean;
+    execute: string | undefined;
+    script: string | undefined;
+    'config-file': string;
+    'r-path': string | undefined;
+}
+export declare const optionHelp: ({
+    header: string;
+    content: string;
+    optionList?: undefined;
+} | {
+    header: string;
+    content: string[];
+    optionList?: undefined;
+} | {
+    header: string;
+    optionList: OptionDefinition[];
+    content?: undefined;
+})[];

package/cli/flowr.js

@@ -0,0 +1,141 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.optionHelp = exports.optionDefinitions = exports.toolName = void 0;
+const server_1 = require("./repl/server/server");
+const net_1 = require("./repl/server/net");
+const version_1 = require("../util/version");
+const log_1 = require("../util/log");
+const ansi_1 = require("../util/ansi");
+const command_line_args_1 = __importDefault(require("command-line-args"));
+const command_line_usage_1 = __importDefault(require("command-line-usage"));
+const config_1 = require("../config");
+const assert_1 = require("../util/assert");
+const scripts_info_1 = require("./common/scripts-info");
+const shell_1 = require("../r-bridge/shell");
+const execute_1 = require("./repl/execute");
+const main_1 = require("./repl/commands/main");
+const core_1 = require("./repl/core");
+const version_2 = require("./repl/commands/version");
+const print_version_1 = require("./repl/print-version");
+const scriptsText = Array.from(Object.entries(scripts_info_1.scripts).filter(([, { type }]) => type === 'master script'), ([k,]) => k).join(', ');
+exports.toolName = 'flowr';
+exports.optionDefinitions = [
+    { name: 'verbose', alias: 'v', type: Boolean, description: 'Run with verbose logging (will be passed to the corresponding script)' },
+    { name: 'help', alias: 'h', type: Boolean, description: 'Print this usage guide (or the guide of the corresponding script)' },
+    { name: 'version', alias: 'V', type: Boolean, description: 'Provide information about the version of flowR as well as its underlying R system and exit.' },
+    { name: 'server', type: Boolean, description: 'Do not drop into a repl, but instead start a server on the given port (default: 1042) and listen for messages.' },
+    { name: 'ws', type: Boolean, description: 'If the server flag is set, use websocket for messaging' },
+    { name: 'port', type: Number, description: 'The port to listen on, if --server is given.', defaultValue: 1042, typeLabel: '{underline port}' },
+    { name: 'execute', alias: 'e', type: String, description: 'Execute the given command and exit. Use a semicolon ";" to separate multiple commands.', typeLabel: '{underline command}', multiple: false },
+    { name: 'no-ansi', type: Boolean, description: 'Disable ansi-escape-sequences in the output. Useful, if you want to redirect the output to a file.' },
+    { name: 'script', alias: 's', type: String, description: `The sub-script to run (${scriptsText})`, multiple: false, defaultOption: true, typeLabel: '{underline files}', defaultValue: undefined },
+    { name: 'config-file', type: String, description: 'The name of the configuration file to use', multiple: false },
+    { name: 'r-path', type: String, description: 'The path to the R executable to use. Defaults to your PATH.', multiple: false }
+];
+exports.optionHelp = [
+    {
+        header: `flowR (version ${(0, version_1.flowrVersion)().toString()})`,
+        content: 'A static dataflow analyzer and program slicer for R programs'
+    },
+    {
+        header: 'Synopsis',
+        content: [
+            `$ ${exports.toolName} {bold --help}`,
+            `$ ${exports.toolName} {bold --version}`,
+            `$ ${exports.toolName} {bold --server}`,
+            `$ ${exports.toolName} {bold --execute} {italic ":parse 2 - 4"}`,
+            `$ ${exports.toolName} {bold slicer} {bold --help}`,
+        ]
+    },
+    {
+        header: 'Options',
+        optionList: exports.optionDefinitions
+    }
+];
+const options = (0, command_line_args_1.default)(exports.optionDefinitions);
+log_1.log.updateSettings(l => l.settings.minLevel = options.verbose ? 1 /* LogLevel.Trace */ : 5 /* LogLevel.Error */);
+log_1.log.info('running with options', options);
+if (options['no-ansi']) {
+    log_1.log.info('disabling ansi colors');
+    (0, ansi_1.setFormatter)(ansi_1.voidFormatter);
+}
+(0, config_1.setConfigFile)(undefined, options['config-file'] ?? config_1.defaultConfigFile, true);
+function retrieveShell() {
+    // we keep an active shell session to allow other parse investigations :)
+    let opts = {
+        revive: 2 /* RShellReviveOptions.Always */,
+        onRevive: (code, signal) => {
+            const signalText = signal == null ? '' : ` and signal ${signal}`;
+            console.log(ansi_1.formatter.format(`R process exited with code ${code}${signalText}. Restarting...`, { color: 5 /* Colors.Magenta */, effect: ansi_1.ColorEffect.Foreground }));
+            console.log((0, ansi_1.italic)(`If you want to exit, press either Ctrl+C twice, or enter ${(0, ansi_1.bold)(':quit')}`));
+        }
+    };
+    if (options['r-path']) {
+        opts = { ...opts, pathToRExecutable: options['r-path'] };
+    }
+    return new shell_1.RShell(opts);
+}
+async function mainRepl() {
+    if (options.script) {
+        let target = scripts_info_1.scripts[options.script].target;
+        (0, assert_1.guard)(target !== undefined, `Unknown script ${options.script}, pick one of ${scriptsText}.`);
+        console.log(`Running script '${ansi_1.formatter.format(options.script, { style: 1 /* FontStyles.Bold */ })}'`);
+        target = `cli/${target}`;
+        log_1.log.debug(`Script maps to "${target}"`);
+        await (0, execute_1.waitOnScript)(`${__dirname}/${target}`, process.argv.slice(3), undefined, true);
+        process.exit(0);
+    }
+    if (options.help) {
+        console.log((0, command_line_usage_1.default)(exports.optionHelp));
+        process.exit(0);
+    }
+    if (options.version) {
+        const shell = new shell_1.RShell();
+        process.on('exit', () => shell.close());
+        await (0, version_2.printVersionInformation)(main_1.standardReplOutput, shell);
+        process.exit(0);
+    }
+    const shell = retrieveShell();
+    const end = () => {
+        if (options.execute === undefined) {
+            console.log(`\n${(0, ansi_1.italic)('Exiting...')}`);
+        }
+        shell.close();
+        process.exit(0);
+    };
+    // hook some handlers
+    process.on('SIGINT', end);
+    process.on('SIGTERM', end);
+    if (options.execute) {
+        await (0, core_1.replProcessAnswer)(main_1.standardReplOutput, options.execute, shell);
+    }
+    else {
+        await (0, print_version_1.printVersionRepl)(shell);
+        await (0, core_1.repl)(shell);
+    }
+    process.exit(0);
+}
+async function mainServer(backend = new net_1.NetServer()) {
+    const shell = retrieveShell();
+    const end = () => {
+        if (options.execute === undefined) {
+            console.log(`\n${(0, ansi_1.italic)('Exiting...')}`);
+        }
+        shell.close();
+        process.exit(0);
+    };
+    // hook some handlers
+    process.on('SIGINT', end);
+    process.on('SIGTERM', end);
+    await new server_1.FlowRServer(shell, backend).start(options.port);
+}
+if (options.server) {
+    void mainServer(options.ws ? new net_1.WebSocketServerWrapper() : new net_1.NetServer());
+}
+else {
+    void mainRepl();
+}
+//# sourceMappingURL=flowr.js.map

package/cli/repl/commands/cfg.d.ts

@@ -0,0 +1,3 @@
+import type { ReplCommand } from './main';
+export declare const controlflowCommand: ReplCommand;
+export declare const controlflowStarCommand: ReplCommand;

package/cli/repl/commands/cfg.js

@@ -0,0 +1,37 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.controlflowStarCommand = exports.controlflowCommand = void 0;
+const pipeline_executor_1 = require("../../../core/pipeline-executor");
+const cfg_1 = require("../../../util/cfg/cfg");
+const default_pipelines_1 = require("../../../core/steps/pipeline/default-pipelines");
+const retriever_1 = require("../../../r-bridge/retriever");
+const cfg_2 = require("../../../util/mermaid/cfg");
+async function controlflow(shell, remainingLine) {
+    return await new pipeline_executor_1.PipelineExecutor(default_pipelines_1.DEFAULT_NORMALIZE_PIPELINE, {
+        shell,
+        request: (0, retriever_1.requestFromInput)(remainingLine.trim())
+    }).allRemainingSteps();
+}
+exports.controlflowCommand = {
+    description: `Get mermaid code for the control-flow graph of R code, start with '${retriever_1.fileProtocol}' to indicate a file`,
+    usageExample: ':controlflow',
+    aliases: ['cfg', 'cf'],
+    script: false,
+    fn: async (output, shell, remainingLine) => {
+        const result = await controlflow(shell, remainingLine);
+        const cfg = (0, cfg_1.extractCFG)(result.normalize);
+        output.stdout((0, cfg_2.cfgToMermaid)(cfg, result.normalize));
+    }
+};
+exports.controlflowStarCommand = {
+    description: `Get a mermaid url of the control-flow graph of R code, start with '${retriever_1.fileProtocol}' to indicate a file`,
+    usageExample: ':controlflow',
+    aliases: ['cfg*', 'cf*'],
+    script: false,
+    fn: async (output, shell, remainingLine) => {
+        const result = await controlflow(shell, remainingLine);
+        const cfg = (0, cfg_1.extractCFG)(result.normalize);
+        output.stdout((0, cfg_2.cfgToMermaidUrl)(cfg, result.normalize));
+    }
+};
+//# sourceMappingURL=cfg.js.map

package/cli/repl/commands/commands.d.ts

@@ -0,0 +1,13 @@
+import type { ReplCommand } from './main';
+export declare const helpCommand: ReplCommand;
+/**
+ * The names of all commands including their aliases (but without the leading `:`)
+ */
+export declare function getCommandNames(): string[];
+/**
+ * Get the command for a given command name or alias.
+ * @param command - The name of the command (without the leading `:`)
+ */
+export declare function getCommand(command: string): ReplCommand | undefined;
+export declare function asOptionName(argument: string): string;
+export declare function longestCommandName(): number;

package/cli/repl/commands/commands.js

@@ -0,0 +1,142 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.longestCommandName = exports.asOptionName = exports.getCommand = exports.getCommandNames = exports.helpCommand = void 0;
+const quit_1 = require("./quit");
+const execute_1 = require("../execute");
+const prompt_1 = require("../prompt");
+const version_1 = require("./version");
+const parse_1 = require("./parse");
+const execute_2 = require("./execute");
+const normalize_1 = require("./normalize");
+const dataflow_1 = require("./dataflow");
+const cfg_1 = require("./cfg");
+const ansi_1 = require("../../../util/ansi");
+const args_1 = require("../../../util/args");
+const assert_1 = require("../../../util/assert");
+const scripts_info_1 = require("../../common/scripts-info");
+function printHelpForScript(script, f) {
+    const base = `  ${(0, ansi_1.bold)(padCmd(':' + script[0]), f)}${script[1].description}`;
+    if (script[1].aliases.length === 0) {
+        return base;
+    }
+    const aliases = script[1].aliases;
+    return `${base} (alias${aliases.length > 1 ? 'es' : ''}: ${aliases.map(a => (0, ansi_1.bold)(':' + a, f)).join(', ')})`;
+}
+exports.helpCommand = {
+    description: 'Show help information',
+    script: false,
+    usageExample: ':help',
+    aliases: ['h', '?'],
+    fn: output => {
+        initCommandMapping();
+        output.stdout(`
+You can always just enter R expressions which get evaluated right away:
+${prompt_1.rawPrompt} ${(0, ansi_1.bold)('1 + 1', output.formatter)}
+${(0, ansi_1.italic)('[1] 2', output.formatter)}
+
+Besides that, you can use the following commands. The scripts ${(0, ansi_1.italic)('can', output.formatter)} accept further arguments. There are the following basic commands:
+${Array.from(Object.entries(commands())).filter(([, { script }]) => !script).map(c => printHelpForScript(c, output.formatter)).join('\n')}
+
+Furthermore, you can directly call the following scripts which accept arguments. If you are unsure, try to add ${(0, ansi_1.italic)('--help', output.formatter)} after the command.
+${Array.from(Object.entries(commands())).filter(([, { script }]) => script).map(([command, { description }]) => `  ${(0, ansi_1.bold)(padCmd(':' + command), output.formatter)}${description}`).join('\n')}
+
+You can combine commands by separating them with a semicolon ${(0, ansi_1.bold)(';', output.formatter)}.
+`);
+    }
+};
+/**
+ * All commands that should be available in the REPL.
+ */
+const _commands = {
+    'help': exports.helpCommand,
+    'quit': quit_1.quitCommand,
+    'version': version_1.versionCommand,
+    'execute': execute_2.executeCommand,
+    'parse': parse_1.parseCommand,
+    'normalize': normalize_1.normalizeCommand,
+    'normalize*': normalize_1.normalizeStarCommand,
+    'dataflow': dataflow_1.dataflowCommand,
+    'dataflow*': dataflow_1.dataflowStarCommand,
+    'controlflow': cfg_1.controlflowCommand,
+    'controlflow*': cfg_1.controlflowStarCommand
+};
+let commandsInitialized = false;
+function commands() {
+    if (commandsInitialized) {
+        return _commands;
+    }
+    commandsInitialized = true;
+    for (const [script, { target, description, type }] of Object.entries(scripts_info_1.scripts)) {
+        if (type === 'master script') {
+            _commands[script] = {
+                description,
+                aliases: [],
+                script: true,
+                usageExample: `:${script} --help`,
+                fn: async (output, _s, remainingLine) => {
+                    await (0, execute_1.waitOnScript)(`${__dirname}/../../${target}`, (0, args_1.splitAtEscapeSensitive)(remainingLine), stdio => (0, execute_1.stdioCaptureProcessor)(stdio, msg => output.stdout(msg), msg => output.stderr(msg)));
+                }
+            };
+        }
+    }
+    return _commands;
+}
+/**
+ * The names of all commands including their aliases (but without the leading `:`)
+ */
+function getCommandNames() {
+    if (commandNames === undefined) {
+        initCommandMapping();
+    }
+    return commandNames;
+}
+exports.getCommandNames = getCommandNames;
+let commandNames = undefined;
+// maps command names or aliases to the actual command name
+let commandMapping = undefined;
+function initCommandMapping() {
+    commandMapping = {};
+    commandNames = [];
+    for (const [command, { aliases }] of Object.entries(commands())) {
+        (0, assert_1.guard)(commandMapping[command] === undefined, `Command ${command} is already registered!`);
+        commandMapping[command] = command;
+        for (const alias of aliases) {
+            (0, assert_1.guard)(commandMapping[alias] === undefined, `Command (alias) ${alias} is already registered!`);
+            commandMapping[alias] = command;
+        }
+        commandNames.push(command);
+        commandNames.push(...aliases);
+    }
+}
+/**
+ * Get the command for a given command name or alias.
+ * @param command - The name of the command (without the leading `:`)
+ */
+function getCommand(command) {
+    if (commandMapping === undefined) {
+        initCommandMapping();
+    }
+    return commands()[commandMapping[command]];
+}
+exports.getCommand = getCommand;
+function asOptionName(argument) {
+    if (argument.length == 1) {
+        return `-${argument}`;
+    }
+    else {
+        return `--${argument}`;
+    }
+}
+exports.asOptionName = asOptionName;
+let _longestCommandName = undefined;
+function longestCommandName() {
+    if (_longestCommandName === undefined) {
+        _longestCommandName = Array.from(Object.keys(commands()), k => k.length).reduce((p, n) => Math.max(p, n), 0);
+    }
+    return _longestCommandName;
+}
+exports.longestCommandName = longestCommandName;
+function padCmd(string) {
+    return String(string).padEnd(longestCommandName() + 2, ' ');
+}
+//# sourceMappingURL=commands.js.map

package/cli/repl/commands/dataflow.d.ts

@@ -0,0 +1,3 @@
+import type { ReplCommand } from './main';
+export declare const dataflowCommand: ReplCommand;
+export declare const dataflowStarCommand: ReplCommand;

package/cli/repl/commands/dataflow.js

@@ -0,0 +1,34 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.dataflowStarCommand = exports.dataflowCommand = void 0;
+const pipeline_executor_1 = require("../../../core/pipeline-executor");
+const default_pipelines_1 = require("../../../core/steps/pipeline/default-pipelines");
+const retriever_1 = require("../../../r-bridge/retriever");
+const dfg_1 = require("../../../util/mermaid/dfg");
+async function dataflow(shell, remainingLine) {
+    return await new pipeline_executor_1.PipelineExecutor(default_pipelines_1.DEFAULT_DATAFLOW_PIPELINE, {
+        shell,
+        request: (0, retriever_1.requestFromInput)(remainingLine.trim())
+    }).allRemainingSteps();
+}
+exports.dataflowCommand = {
+    description: `Get mermaid code for the dataflow graph of R code, start with '${retriever_1.fileProtocol}' to indicate a file`,
+    usageExample: ':dataflow',
+    aliases: ['d', 'df'],
+    script: false,
+    fn: async (output, shell, remainingLine) => {
+        const result = await dataflow(shell, remainingLine);
+        output.stdout((0, dfg_1.graphToMermaid)({ graph: result.dataflow.graph, includeEnvironments: false }).string);
+    }
+};
+exports.dataflowStarCommand = {
+    description: `Get a mermaid url of the dataflow graph of R code, start with '${retriever_1.fileProtocol}' to indicate a file`,
+    usageExample: ':dataflow*',
+    aliases: ['d*', 'df*'],
+    script: false,
+    fn: async (output, shell, remainingLine) => {
+        const result = await dataflow(shell, remainingLine);
+        output.stdout((0, dfg_1.graphToMermaidUrl)(result.dataflow.graph, false));
+    }
+};
+//# sourceMappingURL=dataflow.js.map

package/cli/repl/commands/execute.d.ts

@@ -0,0 +1,4 @@
+import type { ReplCommand, ReplOutput } from './main';
+import type { RShell } from '../../../r-bridge/shell';
+export declare function executeRShellCommand(output: ReplOutput, shell: RShell, statement: string): Promise<void>;
+export declare const executeCommand: ReplCommand;

package/cli/repl/commands/execute.js

@@ -0,0 +1,27 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.executeCommand = exports.executeRShellCommand = void 0;
+const ansi_1 = require("../../../util/ansi");
+async function executeRShellCommand(output, shell, statement) {
+    try {
+        const result = await shell.sendCommandWithOutput(statement, {
+            from: 'both',
+            automaticallyTrimOutput: true
+        });
+        output.stdout(`${(0, ansi_1.italic)(result.join('\n'), output.formatter)}\n`);
+    }
+    catch (e) {
+        output.stderr(`Error while executing '${statement}': ${e.message}`);
+    }
+}
+exports.executeRShellCommand = executeRShellCommand;
+exports.executeCommand = {
+    description: 'Execute the given code as R code (essentially similar to using now command)',
+    usageExample: ':execute',
+    aliases: ['e', 'r'],
+    script: false,
+    fn: async (output, shell, remainingLine) => {
+        await executeRShellCommand(output, shell, remainingLine);
+    }
+};
+//# sourceMappingURL=execute.js.map

package/cli/repl/commands/main.d.ts

@@ -0,0 +1,39 @@
+import type { OutputFormatter } from '../../../util/ansi';
+import type { RShell } from '../../../r-bridge/shell';
+/**
+ * Defines the main interface for output of the repl.
+ * This allows us to redirect it (e.g., in the case of a server connection or tests).
+ *
+ * The formatter allows to dynamically change the use of ansi escape sequences (see {@link OutputFormatter})
+ *
+ * @see standardReplOutput
+ */
+export interface ReplOutput {
+    formatter: OutputFormatter;
+    stdout(msg: string): void;
+    stderr(msg: string): void;
+}
+/**
+ * Default repl output that redirects everything to the stdout and stderror channels (linked to `console`).
+ * @see ReplOutput
+ */
+export declare const standardReplOutput: ReplOutput;
+/**
+ * Content of a single command in the repl.
+ * The command may execute an external script or simply call *flowR* functions.
+ */
+export interface ReplCommand {
+    /** Aliases of the command (without the leading colon), every alias must be unique (this is checked at runtime) */
+    aliases: string[];
+    /** A human-readable description of what the command does */
+    description: string;
+    /** Does the command invoke another script? this is mainly used to automatically generate two separate lists when asking for help */
+    script: boolean;
+    /** Example of how to use the command, for example `:slicer --help` */
+    usageExample: string;
+    /**
+     * Function to execute when the command is invoked, it must not write to the command line but instead use the output handler.
+     * Furthermore, it has to obey the formatter defined in the {@link ReplOutput}.
+     */
+    fn: (output: ReplOutput, shell: RShell, remainingLine: string) => Promise<void> | void;
+}

package/cli/repl/commands/main.js

@@ -0,0 +1,14 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.standardReplOutput = void 0;
+const ansi_1 = require("../../../util/ansi");
+/**
+ * Default repl output that redirects everything to the stdout and stderror channels (linked to `console`).
+ * @see ReplOutput
+ */
+exports.standardReplOutput = {
+    formatter: ansi_1.formatter,
+    stdout: console.log,
+    stderr: console.error
+};
+//# sourceMappingURL=main.js.map

package/cli/repl/commands/normalize.d.ts

@@ -0,0 +1,3 @@
+import type { ReplCommand } from './main';
+export declare const normalizeCommand: ReplCommand;
+export declare const normalizeStarCommand: ReplCommand;

package/cli/repl/commands/normalize.js

@@ -0,0 +1,34 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.normalizeStarCommand = exports.normalizeCommand = void 0;
+const pipeline_executor_1 = require("../../../core/pipeline-executor");
+const default_pipelines_1 = require("../../../core/steps/pipeline/default-pipelines");
+const retriever_1 = require("../../../r-bridge/retriever");
+const ast_1 = require("../../../util/mermaid/ast");
+async function normalize(shell, remainingLine) {
+    return await new pipeline_executor_1.PipelineExecutor(default_pipelines_1.DEFAULT_NORMALIZE_PIPELINE, {
+        shell,
+        request: (0, retriever_1.requestFromInput)(remainingLine.trim())
+    }).allRemainingSteps();
+}
+exports.normalizeCommand = {
+    description: `Get mermaid code for the normalized AST of R code, start with '${retriever_1.fileProtocol}' to indicate a file`,
+    usageExample: ':normalize',
+    aliases: ['n'],
+    script: false,
+    fn: async (output, shell, remainingLine) => {
+        const result = await normalize(shell, remainingLine);
+        output.stdout((0, ast_1.normalizedAstToMermaid)(result.normalize.ast));
+    }
+};
+exports.normalizeStarCommand = {
+    description: `Get a mermaid url of the normalized AST of R code, start with '${retriever_1.fileProtocol}' to indicate a file`,
+    usageExample: ':normalize',
+    aliases: ['n*'],
+    script: false,
+    fn: async (output, shell, remainingLine) => {
+        const result = await normalize(shell, remainingLine);
+        output.stdout((0, ast_1.normalizedAstToMermaidUrl)(result.normalize.ast));
+    }
+};
+//# sourceMappingURL=normalize.js.map

package/cli/repl/commands/parse.d.ts

@@ -0,0 +1,2 @@
+import type { ReplCommand } from './main';
+export declare const parseCommand: ReplCommand;

package/cli/repl/commands/parse.js

@@ -0,0 +1,110 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.parseCommand = void 0;
+const pipeline_executor_1 = require("../../../core/pipeline-executor");
+const format_1 = require("../../../r-bridge/lang-4.x/ast/parser/json/format");
+const parser_1 = require("../../../r-bridge/lang-4.x/ast/parser/json/parser");
+const input_format_1 = require("../../../r-bridge/lang-4.x/ast/parser/xml/input-format");
+const normalize_meta_1 = require("../../../r-bridge/lang-4.x/ast/parser/xml/normalize-meta");
+const default_pipelines_1 = require("../../../core/steps/pipeline/default-pipelines");
+const retriever_1 = require("../../../r-bridge/retriever");
+function toDepthMap(xml) {
+    const root = (0, input_format_1.getKeysGuarded)(xml, "exprlist" /* RawRType.ExpressionList */);
+    const visit = [{ depth: 0, node: root }];
+    const result = [];
+    while (visit.length > 0) {
+        const current = visit.pop();
+        if (current === undefined) {
+            continue;
+        }
+        const children = current.node[input_format_1.childrenKey] ?? [];
+        result.push({ ...current, leaf: children.length === 0 });
+        children.reverse();
+        const nextDepth = current.depth + 1;
+        visit.push(...children.map(c => ({ depth: nextDepth, node: c })));
+    }
+    return result;
+}
+function lastElementInNesting(i, list, depth) {
+    for (let j = i + 1; j < list.length; j++) {
+        if (list[j].depth < depth) {
+            return true;
+        }
+        if (list[j].depth === depth) {
+            return false;
+        }
+    }
+    // only more deeply nested come after
+    return true;
+}
+function initialIndentation(i, depth, deadDepths, nextDepth, list, f) {
+    let result = `${i === 0 ? '' : '\n'}${f.getFormatString({ style: 2 /* FontStyles.Faint */ })}`;
+    // we know there never is something on the same level as the expression list
+    for (let d = 1; d < depth; d++) {
+        result += deadDepths.has(d) ? '  ' : '│ ';
+    }
+    if (nextDepth < depth) {
+        result += '╰ ';
+    }
+    else if (i > 0) {
+        // check if we are maybe the last one with this depth until someone with a lower depth comes around
+        const isLast = lastElementInNesting(i, list, depth);
+        result += isLast ? '╰ ' : '├ ';
+        if (isLast) {
+            deadDepths.add(depth);
+        }
+    }
+    return result;
+}
+function retrieveLocationString(locationRaw) {
+    const extracted = (0, normalize_meta_1.extractLocation)(locationRaw);
+    if (extracted[0] === extracted[2] && extracted[1] === extracted[3]) {
+        return ` (${extracted[0]}:${extracted[1]})`;
+    }
+    else {
+        return ` (${extracted[0]}:${extracted[1]}─${extracted[2]}:${extracted[3]})`;
+    }
+}
+function depthListToTextTree(list, f) {
+    let result = '';
+    const deadDepths = new Set();
+    let i = 0;
+    for (const { depth, node, leaf } of list) {
+        const nextDepth = i + 1 < list.length ? list[i + 1].depth : 0;
+        deadDepths.delete(depth);
+        result += initialIndentation(i, depth, deadDepths, nextDepth, list, f);
+        result += f.reset();
+        const raw = (0, normalize_meta_1.objectWithArrUnwrap)(node);
+        const content = raw[input_format_1.contentKey];
+        const locationRaw = raw[input_format_1.attributesKey];
+        let location = '';
+        if (locationRaw !== undefined) {
+            location = retrieveLocationString(locationRaw);
+        }
+        const type = (0, normalize_meta_1.getTokenType)(node);
+        if (leaf) {
+            const suffix = `${f.format(content ? JSON.stringify(content) : '', { style: 1 /* FontStyles.Bold */ })}${f.format(location, { style: 3 /* FontStyles.Italic */ })}`;
+            result += `${type} ${suffix}`;
+        }
+        else {
+            result += f.format(type, { style: 1 /* FontStyles.Bold */ });
+        }
+        i++;
+    }
+    return result;
+}
+exports.parseCommand = {
+    description: `Prints ASCII Art of the parsed, unmodified AST, start with '${retriever_1.fileProtocol}' to indicate a file`,
+    usageExample: ':parse',
+    aliases: ['p'],
+    script: false,
+    fn: async (output, shell, remainingLine) => {
+        const result = await new pipeline_executor_1.PipelineExecutor(default_pipelines_1.DEFAULT_PARSE_PIPELINE, {
+            shell,
+            request: (0, retriever_1.requestFromInput)((0, retriever_1.removeRQuotes)(remainingLine.trim()))
+        }).allRemainingSteps();
+        const object = (0, parser_1.convertPreparedParsedData)((0, format_1.prepareParsedData)(result.parse));
+        output.stdout(depthListToTextTree(toDepthMap(object), output.formatter));
+    }
+};
+//# sourceMappingURL=parse.js.map

package/cli/repl/commands/quit.d.ts

@@ -0,0 +1,2 @@
+import type { ReplCommand } from './main';
+export declare const quitCommand: ReplCommand;