@eagleoutice/flowr 1.3.11

package/r-bridge/lang-4.x/ast/parser/xml/v2/internal/root.js

@@ -0,0 +1,26 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.normalizeRoot = void 0;
+const input_format_1 = require("../../common/input-format");
+const expression_1 = require("./expression");
+const normalize_1 = require("../normalize");
+function normalizeRoot(config, obj) {
+    const exprContent = (0, input_format_1.getKeyGuarded)(obj, "exprlist" /* RawRType.ExpressionList */);
+    let normalized = [];
+    // the children of an expression list are an array of expressions
+    if (config.children in exprContent) {
+        const children = (0, input_format_1.getKeyGuarded)(exprContent, config.children);
+        normalized = (0, expression_1.normalizeExpression)(config, children);
+    }
+    else {
+        normalize_1.normalizeLog.debug('assume empty root');
+    }
+    return {
+        type: "RExpressionList" /* RType.ExpressionList */,
+        children: normalized,
+        lexeme: undefined,
+        info: {}
+    };
+}
+exports.normalizeRoot = normalizeRoot;
+//# sourceMappingURL=root.js.map

package/r-bridge/lang-4.x/ast/parser/xml/v2/internal/single-element.js

@@ -0,0 +1,63 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.normalizeSingleToken = void 0;
+const input_format_1 = require("../../common/input-format");
+const expression_1 = require("./expression");
+const values_1 = require("./values");
+const string_1 = require("./values/string");
+const symbol_1 = require("./values/symbol");
+const assert_1 = require("../../../../../../../util/assert");
+const other_1 = require("./other");
+const line_directive_1 = require("./other/line-directive");
+const meta_1 = require("../../common/meta");
+const todo = (...x) => { throw new Error('not implemented: ' + JSON.stringify(x)); };
+/**
+ * Parses a single structure in the ast based on its type (e.g., a string, a number, a symbol, ...)
+ *
+ * @param config - The data used by the parser (see {@link ParserData})
+ * @param token  - The element to parse
+ *
+ * @returns The parsed element as an `RNode` or an `RDelimiter` if it is such.
+ */
+function normalizeSingleToken(config, token) {
+    const name = (0, meta_1.getTokenType)(config.tokenMap, token);
+    switch (name) {
+        case "(" /* RawRType.ParenLeft */:
+        case ")" /* RawRType.ParenRight */:
+        case "{" /* RawRType.BraceLeft */:
+        case "}" /* RawRType.BraceRight */:
+            return todo(name);
+        case "COMMENT" /* RawRType.Comment */:
+            return (0, other_1.normalizeComment)(config, token);
+        case "LINE_DIRECTIVE" /* RawRType.LineDirective */:
+            return (0, line_directive_1.normalizeLineDirective)(config, token);
+        case "exprlist" /* RawRType.ExpressionList */:
+        case "expr" /* RawRType.Expression */:
+        case "expr_or_assign_or_help" /* RawRType.ExprOfAssignOrHelp */: {
+            config.currentLexeme = token[config.content];
+            const res = (0, expression_1.normalizeExpression)(config, (0, input_format_1.getKeyGuarded)(token, config.children));
+            (0, assert_1.guard)(res.length === 1, () => `expected only one element in the expression list, yet received ${JSON.stringify(res)}`);
+            return res[0];
+        }
+        case "NUM_CONST" /* RawRType.NumericConst */:
+            return (0, values_1.normalizeNumber)(config, token);
+        case "STR_CONST" /* RawRType.StringConst */:
+            return (0, string_1.normalizeString)(config, token);
+        case "BREAK" /* RawRType.Break */:
+            return todo(name);
+        case "NEXT" /* RawRType.Next */:
+            return todo(name);
+        case "SYMBOL" /* RawRType.Symbol */:
+        case "SLOT" /* RawRType.Slot */:
+        case "NULL_CONST" /* RawRType.NullConst */: {
+            // TODO: optimize manually?
+            const symbol = (0, symbol_1.tryNormalizeSymbolNoNamespace)(config, token);
+            (0, assert_1.guard)(symbol !== undefined, () => `should have been parsed to a symbol but was ${JSON.stringify(symbol)}`);
+            return symbol;
+        }
+        default:
+            throw new input_format_1.XmlParseError(`unknown type ${name} for ${JSON.stringify(token)} in ${JSON.stringify(config)}`);
+    }
+}
+exports.normalizeSingleToken = normalizeSingleToken;
+//# sourceMappingURL=single-element.js.map

package/r-bridge/lang-4.x/ast/parser/xml/v2/internal/values/index.js

@@ -0,0 +1,18 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __exportStar = (this && this.__exportStar) || function(m, exports) {
+    for (var p in m) if (p !== "default" && !Object.prototype.hasOwnProperty.call(exports, p)) __createBinding(exports, m, p);
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+__exportStar(require("./number"), exports);
+//# sourceMappingURL=index.js.map

package/r-bridge/lang-4.x/ast/parser/xml/v2/internal/values/number.js

@@ -0,0 +1,46 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.normalizeNumber = void 0;
+const values_1 = require("../../../../../../values");
+const meta_1 = require("../../../common/meta");
+/**
+ * Normalize the given object as a R number (see {@link number2ts}), supporting booleans (see {@link boolean2ts}),
+ * and special values.
+ * This requires you to check the corresponding name beforehand.
+ *
+ * @param config - The configuration used by the normalizer (see {@link NormalizeConfiguration})
+ * @param obj  - The json object to extract the meta-information from
+ */
+function normalizeNumber(config, obj) {
+    const { location, content } = (0, meta_1.retrieveMetaStructure)(config, obj);
+    const common = {
+        location,
+        lexeme: content,
+        info: {}
+    };
+    /* the special symbol */
+    if ((0, values_1.isNA)(content)) {
+        return {
+            ...common,
+            namespace: undefined,
+            type: "RSymbol" /* RType.Symbol */,
+            content
+        };
+    }
+    else if ((0, values_1.isBoolean)(content)) {
+        return {
+            ...common,
+            type: "RLogical" /* RType.Logical */,
+            content: (0, values_1.boolean2ts)(content)
+        };
+    }
+    else {
+        return {
+            ...common,
+            type: "RNumber" /* RType.Number */,
+            content: (0, values_1.number2ts)(content)
+        };
+    }
+}
+exports.normalizeNumber = normalizeNumber;
+//# sourceMappingURL=number.js.map

package/r-bridge/lang-4.x/ast/parser/xml/v2/internal/values/string.js

@@ -0,0 +1,33 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.normalizeString = void 0;
+const meta_1 = require("../../../common/meta");
+const values_1 = require("../../../../../../values");
+const assert_1 = require("../../../../../../../../util/assert");
+/**
+ * Normalize the given object as a R string (see {@link string2ts}).
+ * This requires you to check the corresponding name beforehand.
+ *
+ * @param config - The configuration used by the normalizer
+ * @param obj  - The json object to extract the meta-information from
+ */
+function normalizeString(config, obj) {
+    const { location, content } = (0, meta_1.retrieveMetaStructure)(config, obj);
+    // based on https://www.rdocumentation.org/packages/utils/versions/3.6.2/topics/getParseData we do not get strings with 1000 characters or more within the text field.
+    // therefore, we recover the full string from the surrounding expr lexeme field
+    let stringContent = content;
+    if (stringContent.startsWith('[')) { // something like "[9999 chars quoted with '"']"
+        // ... as they are not stored by the R parser post-processor
+        (0, assert_1.guard)(config.currentLexeme !== undefined, 'need cur. lexeme for too long strings');
+        stringContent = config.currentLexeme;
+    }
+    return {
+        type: "RString" /* RType.String */,
+        location,
+        content: (0, values_1.string2ts)(stringContent),
+        lexeme: stringContent,
+        info: {}
+    };
+}
+exports.normalizeString = normalizeString;
+//# sourceMappingURL=string.js.map

package/r-bridge/lang-4.x/ast/parser/xml/v2/internal/values/symbol.js

@@ -0,0 +1,63 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.tryNormalizeSymbolWithNamespace = exports.tryNormalizeSymbolNoNamespace = void 0;
+const meta_1 = require("../../../common/meta");
+const model_1 = require("../../../../../model");
+const strings_1 = require("../../../../../../../../util/strings");
+const xml_to_json_1 = require("../../../common/xml-to-json");
+// remove backticks from symbol
+function removeBackticks(content) {
+    return (0, strings_1.startAndEndsWith)(content, '`') ? content.substring(1, content.length - 1) : content;
+}
+/**
+ * Normalize the given object as an R symbol without namespace information.
+ * For the variant with namespace information, see {@link tryNormalizeSymbolWithNamespace}.
+ *
+ * @param config - The configuration used by the normalizer
+ * @param symbol - The json object to extract the symbol from
+ *
+ * @returns The parsed symbol or `undefined` if the given object is not a symbol.
+ */
+function tryNormalizeSymbolNoNamespace(config, symbol) {
+    const name = symbol[xml_to_json_1.XML_NAME];
+    if (!(0, model_1.isSymbol)(name)) {
+        return undefined;
+    }
+    const { location, content } = (0, meta_1.retrieveMetaStructure)(config, symbol);
+    return {
+        type: "RSymbol" /* RType.Symbol */,
+        namespace: undefined,
+        location,
+        content: removeBackticks(content),
+        lexeme: content,
+        info: {}
+    };
+}
+exports.tryNormalizeSymbolNoNamespace = tryNormalizeSymbolNoNamespace;
+/**
+ * Normalize the given object as an R symbol without namespace information.
+ * For the variant without namespace information, see {@link tryNormalizeSymbolNoNamespace}.
+ *
+ * @param config - The configuration used by the normalizer
+ * @param namespace - The json object to extract the namespace from
+ * @param symbol - The json object to extract the symbol from
+ *
+ * @returns The parsed symbol (with populated namespace information) or `undefined` if the given object is not a symbol.
+ */
+function tryNormalizeSymbolWithNamespace(config, [namespace, , symbol]) {
+    const name = symbol[xml_to_json_1.XML_NAME];
+    if (!(0, model_1.isSymbol)(name)) {
+        return undefined;
+    }
+    const { location, content } = (0, meta_1.retrieveMetaStructure)(config, symbol);
+    return {
+        type: "RSymbol" /* RType.Symbol */,
+        namespace: namespace[config.content],
+        location,
+        content: removeBackticks(content),
+        lexeme: content,
+        info: {}
+    };
+}
+exports.tryNormalizeSymbolWithNamespace = tryNormalizeSymbolWithNamespace;
+//# sourceMappingURL=symbol.js.map

package/r-bridge/lang-4.x/ast/parser/xml/v2/normalize.js

@@ -0,0 +1,25 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.normalize = exports.normalizeLog = void 0;
+const log_1 = require("../../../../../../util/log");
+const config_1 = require("../common/config");
+const model_1 = require("../../../model");
+const xml_to_json_1 = require("../common/xml-to-json");
+const root_1 = require("./internal/root");
+exports.normalizeLog = log_1.log.getSubLogger({ name: 'v2-normalize' });
+/**
+ * The main entry point to normalize the given R ast (using v2, which desugars the AST to function-calls only).
+ *
+ * @param xmlString - The XML string obtained probably by {@link retrieveXmlFromRCode} to normalization and desugar.
+ * @param tokenMap  - The token replacement map in effect by the XML parser
+ * @param getId     - The function to be used to generate unique ids for the nodes of the ast. It is up to you to ensure that the ids are unique!
+ *
+ * @returns The normalized and decorated AST (i.e., as a doubly linked tree)
+ */
+async function normalize(xmlString, tokenMap, getId = (0, model_1.deterministicCountingIdGenerator)(0)) {
+    const config = { ...config_1.DEFAULT_XML_PARSER_CONFIG, tokenMap, currentLexeme: undefined };
+    const object = await (0, xml_to_json_1.xlm2jsonObject)(config, xmlString);
+    return (0, model_1.decorateAst)((0, root_1.normalizeRoot)(config, object), getId);
+}
+exports.normalize = normalize;
+//# sourceMappingURL=normalize.js.map

package/r-bridge/lang-4.x/index.d.ts

@@ -0,0 +1,2 @@
+export * from './values';
+export * from './ast';

package/r-bridge/lang-4.x/index.js

@@ -0,0 +1,19 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __exportStar = (this && this.__exportStar) || function(m, exports) {
+    for (var p in m) if (p !== "default" && !Object.prototype.hasOwnProperty.call(exports, p)) __createBinding(exports, m, p);
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+__exportStar(require("./values"), exports);
+__exportStar(require("./ast"), exports);
+//# sourceMappingURL=index.js.map

package/r-bridge/lang-4.x/values.d.ts

@@ -0,0 +1,39 @@
+/**
+ * transforms a value to something R can understand (e.g., booleans to TRUE/FALSE)
+ */
+export declare function ts2r<T>(value: T): string;
+/** The R literal for the logical true */
+export declare const RTrue = "TRUE";
+/** The R literal for the logical false */
+export declare const RFalse = "FALSE";
+export declare function isBoolean(value: string): boolean;
+export declare function boolean2ts(value: string): boolean;
+export declare const RNumHexFloatRegex: RegExp;
+export declare const RImaginaryMarker = "i";
+export declare const RIntegerMarker = "L";
+export declare const RInf = "Inf";
+export interface RNumberValue {
+    num: number;
+    /** see {@link RIntegerMarker}, still, R treats 1.1L as numeric and not especially integer */
+    markedAsInt: boolean;
+    /** see {@link RImaginaryMarker}, compound imaginary numbers are expressions in R */
+    complexNumber: boolean;
+}
+export declare function number2ts(value: string): RNumberValue;
+export interface RStringValue {
+    str: string;
+    /** from the R-language definition a string is either delimited by a pair of single or double quotes */
+    quotes: '"' | '\'';
+    /** a string is raw if prefixed with r */
+    flag?: 'raw';
+}
+/**
+ * Convert a valid R string into a {@link RStringValue}.
+ *
+ * @throws {@link ValueConversionError} if the string has an unknown starting quote
+ */
+export declare function string2ts(value: string): RStringValue;
+export declare const RNa = "NA";
+export declare const RNull = "NULL";
+export declare function isNA(value: string): value is (typeof RNa);
+export declare function parseCSV(lines: string[]): string[][];

package/r-bridge/lang-4.x/values.js

@@ -0,0 +1,149 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.parseCSV = exports.isNA = exports.RNull = exports.RNa = exports.string2ts = exports.number2ts = exports.RInf = exports.RIntegerMarker = exports.RImaginaryMarker = exports.RNumHexFloatRegex = exports.boolean2ts = exports.isBoolean = exports.RFalse = exports.RTrue = exports.ts2r = void 0;
+const sync_1 = require("csv-parse/sync");
+class ValueConversionError extends Error {
+    constructor(message) {
+        super(message);
+        this.name = 'ValueConversionError';
+    }
+}
+/**
+ * transforms a value to something R can understand (e.g., booleans to TRUE/FALSE)
+ */
+function ts2r(value) {
+    if (typeof value === 'undefined') {
+        return 'NA';
+    }
+    else if (typeof value === 'string') {
+        return JSON.stringify(value);
+    }
+    else if (typeof value === 'number') {
+        return value.toString();
+    }
+    else if (typeof value === 'boolean') {
+        return value ? 'TRUE' : 'FALSE';
+    }
+    else if (value === null) {
+        return 'NULL';
+    }
+    else if (Array.isArray(value)) {
+        return `c(${value.map(ts2r).join(', ')})`;
+    }
+    else if (typeof value === 'object') {
+        const obj = Object.entries(value)
+            .map(([key, value]) => `${key} = ${ts2r(value)}`)
+            .join(', ');
+        return `list(${obj})`;
+    }
+    throw new ValueConversionError(`cannot convert value of type ${typeof value} to R code`);
+}
+exports.ts2r = ts2r;
+/** The R literal for the logical true */
+exports.RTrue = 'TRUE';
+/** The R literal for the logical false */
+exports.RFalse = 'FALSE';
+function isBoolean(value) {
+    return value === exports.RTrue || value === exports.RFalse;
+}
+exports.isBoolean = isBoolean;
+function boolean2ts(value) {
+    if (value === exports.RTrue) {
+        return true;
+    }
+    else if (value === exports.RFalse) {
+        return false;
+    }
+    throw new ValueConversionError(`value ${value} is not a legal R boolean`);
+}
+exports.boolean2ts = boolean2ts;
+exports.RNumHexFloatRegex = /^\s*0x(?<intPart>[0-9a-f]+)?(\.(?<floatPart>[0-9a-f]*))?p(?<exp>[-+]?\d+)\s*$/;
+function getDecimalPlacesWithRadix(floatPart, radix) {
+    return [...floatPart].reduce((acc, c, idx) => acc + parseInt(c, radix) / (radix ** (idx + 1)), 0);
+}
+exports.RImaginaryMarker = 'i';
+exports.RIntegerMarker = 'L';
+exports.RInf = 'Inf';
+function number2ts(value) {
+    // check for hexadecimal number with floating point addon which is supported by R but not by JS :/
+    let lcValue = value.toLowerCase();
+    /* both checks are case-sensitive! */
+    const last = value[value.length - 1];
+    const markedAsInt = last === exports.RIntegerMarker;
+    const complexNumber = last === exports.RImaginaryMarker;
+    if (markedAsInt || complexNumber) {
+        lcValue = lcValue.slice(0, -1);
+    }
+    if (value === exports.RInf) {
+        return {
+            num: Infinity,
+            complexNumber,
+            markedAsInt
+        };
+    }
+    const floatHex = lcValue.match(exports.RNumHexFloatRegex);
+    if (floatHex == null) {
+        return {
+            num: Number(lcValue),
+            complexNumber,
+            markedAsInt
+        };
+    }
+    else {
+        const { intPart, floatPart, exp } = floatHex.groups;
+        const base = intPart === undefined ? 0 : parseInt(`${intPart}`, 16);
+        const floatSuffix = floatPart === undefined ? 0 : getDecimalPlacesWithRadix(floatPart, 16);
+        const exponent = parseInt(exp, 10);
+        return {
+            num: (base + floatSuffix) * Math.pow(2, exponent),
+            complexNumber,
+            markedAsInt
+        };
+    }
+}
+exports.number2ts = number2ts;
+/**
+ * Convert a valid R string into a {@link RStringValue}.
+ *
+ * @throws {@link ValueConversionError} if the string has an unknown starting quote
+ */
+function string2ts(value) {
+    if (value.length < 2) {
+        throw new ValueConversionError(`cannot parse string '${value}' as it is too short`);
+    }
+    const init = value[0];
+    if (init === '"' || init === '\'') {
+        return {
+            str: value.slice(1, -1),
+            quotes: init
+        };
+    }
+    else if (init === 'r' || init === 'R' && value.length >= 3) {
+        const flags = value[1];
+        if (flags === '"' || flags === '\'') {
+            return {
+                str: value.slice(2, -1),
+                quotes: flags,
+                flag: 'raw'
+            };
+        }
+        else {
+            throw new ValueConversionError(`expected string to start with a known quote (' or "), or raw, yet received ${value}`);
+        }
+    }
+    else {
+        throw new ValueConversionError(`expected string to start with a known quote (' or "), or raw, yet received ${value}`);
+    }
+}
+exports.string2ts = string2ts;
+exports.RNa = 'NA';
+exports.RNull = 'NULL';
+function isNA(value) {
+    return value === exports.RNa;
+}
+exports.isNA = isNA;
+function parseCSV(lines) {
+    return (0, sync_1.parse)(lines.join('\n'), { skipEmptyLines: true });
+}
+exports.parseCSV = parseCSV;
+//# sourceMappingURL=values.js.map

package/r-bridge/retriever.d.ts

@@ -0,0 +1,48 @@
+import { type RShell } from './shell';
+import { XmlParserHooks, NormalizedAst } from './lang-4.x';
+import { DeepPartial, DeepReadonly } from 'ts-essentials';
+export interface RParseRequestFromFile {
+    request: 'file';
+    /** The path to the file (absolute paths are probably best here */
+    content: string;
+}
+export interface RParseRequestFromText {
+    request: 'text';
+    content: string;
+}
+interface RParseRequestBase {
+    /**
+   * Ensure that all required packages are present and if not install them?
+   * The only reason to set this to `false` is probably in a series of parse requests for the same session.
+   */
+    ensurePackageInstalled: boolean;
+}
+/**
+ * A request that can be passed along to {@link retrieveXmlFromRCode}.
+ */
+export type RParseRequest = (RParseRequestFromFile | RParseRequestFromText) & RParseRequestBase;
+export declare function requestFromInput(input: `file://${string}`): RParseRequestFromFile & RParseRequestBase;
+export declare function requestFromInput(input: string): RParseRequestFromText & RParseRequestBase;
+/**
+ * Provides the capability to parse R files/R code using the R parser.
+ * Depends on {@link RShell} to provide a connection to R.
+ * <p>
+ * Throws if the file could not be parsed.
+ * If successful, allows to further query the last result with {@link retrieveNumberOfRTokensOfLastParse}.
+ */
+export declare function retrieveXmlFromRCode(request: RParseRequest, shell: RShell): Promise<string>;
+/**
+ * Uses {@link retrieveXmlFromRCode} and returns the nicely formatted object-AST.
+ * If successful, allows to further query the last result with {@link retrieveNumberOfRTokensOfLastParse}.
+ */
+export declare function retrieveNormalizedAstFromRCode(request: RParseRequest, shell: RShell, hooks?: DeepPartial<XmlParserHooks>): Promise<NormalizedAst>;
+/**
+ * If the string has (R-)quotes around it, they will be removed, otherwise the string is returned unchanged.
+ */
+export declare function removeTokenMapQuotationMarks(str: string): string;
+export type TokenMap = DeepReadonly<Record<string, string>>;
+/**
+ * Needs to be called *after*  {@link retrieveXmlFromRCode} (or {@link retrieveNormalizedAstFromRCode})
+ */
+export declare function retrieveNumberOfRTokensOfLastParse(shell: RShell): Promise<number>;
+export {};

package/r-bridge/retriever.js

@@ -0,0 +1,71 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.retrieveNumberOfRTokensOfLastParse = exports.removeTokenMapQuotationMarks = exports.retrieveNormalizedAstFromRCode = exports.retrieveXmlFromRCode = exports.requestFromInput = void 0;
+const lang_4_x_1 = require("./lang-4.x");
+const strings_1 = require("../util/strings");
+const assert_1 = require("../util/assert");
+/**
+ * Creates a {@link RParseRequest} from a given input.
+ */
+function requestFromInput(input) {
+    const file = input.startsWith('file://');
+    return {
+        request: file ? 'file' : 'text',
+        content: file ? input.slice(7) : input,
+        ensurePackageInstalled: false // should be called within describeSession for that!
+    };
+}
+exports.requestFromInput = requestFromInput;
+const ErrorMarker = 'err';
+/**
+ * Provides the capability to parse R files/R code using the R parser.
+ * Depends on {@link RShell} to provide a connection to R.
+ * <p>
+ * Throws if the file could not be parsed.
+ * If successful, allows to further query the last result with {@link retrieveNumberOfRTokensOfLastParse}.
+ */
+async function retrieveXmlFromRCode(request, shell) {
+    if (request.ensurePackageInstalled) {
+        await shell.ensurePackageInstalled('xmlparsedata', true);
+    }
+    const suffix = request.request === 'file' ? ', encoding="utf-8"' : '';
+    shell.sendCommands(`flowr_output <- flowr_parsed <- "${ErrorMarker}"`, 
+    // now, try to retrieve the ast
+    `try(flowr_parsed<-parse(${request.request}=${JSON.stringify(request.content)},keep.source=TRUE${suffix}),silent=FALSE)`, 'try(flowr_output<-xmlparsedata::xml_parse_data(flowr_parsed,includeText=TRUE,pretty=FALSE),silent=FALSE)');
+    const xml = await shell.sendCommandWithOutput(`cat(flowr_output,${(0, lang_4_x_1.ts2r)(shell.options.eol)})`);
+    const output = xml.join(shell.options.eol);
+    (0, assert_1.guard)(output !== ErrorMarker, () => `unable to parse R code (see the log for more information) for request ${JSON.stringify(request)}}`);
+    return output;
+}
+exports.retrieveXmlFromRCode = retrieveXmlFromRCode;
+/**
+ * Uses {@link retrieveXmlFromRCode} and returns the nicely formatted object-AST.
+ * If successful, allows to further query the last result with {@link retrieveNumberOfRTokensOfLastParse}.
+ */
+async function retrieveNormalizedAstFromRCode(request, shell, hooks) {
+    const xml = await retrieveXmlFromRCode(request, shell);
+    return await (0, lang_4_x_1.normalize)(xml, await shell.tokenMap(), hooks);
+}
+exports.retrieveNormalizedAstFromRCode = retrieveNormalizedAstFromRCode;
+/**
+ * If the string has (R-)quotes around it, they will be removed, otherwise the string is returned unchanged.
+ */
+function removeTokenMapQuotationMarks(str) {
+    if (str.length > 1 && ((0, strings_1.startAndEndsWith)(str, '\'') || (0, strings_1.startAndEndsWith)(str, '"'))) {
+        return str.slice(1, -1);
+    }
+    else {
+        return str;
+    }
+}
+exports.removeTokenMapQuotationMarks = removeTokenMapQuotationMarks;
+/**
+ * Needs to be called *after*  {@link retrieveXmlFromRCode} (or {@link retrieveNormalizedAstFromRCode})
+ */
+async function retrieveNumberOfRTokensOfLastParse(shell) {
+    const result = await shell.sendCommandWithOutput(`cat(nrow(getParseData(flowr_parsed)),${(0, lang_4_x_1.ts2r)(shell.options.eol)})`);
+    (0, assert_1.guard)(result.length === 1, () => `expected exactly one line to obtain the number of R tokens, but got: ${JSON.stringify(result)}`);
+    return Number(result[0]);
+}
+exports.retrieveNumberOfRTokensOfLastParse = retrieveNumberOfRTokensOfLastParse;
+//# sourceMappingURL=retriever.js.map