@eagleoutice/flowr 1.3.11

package/r-bridge/lang-4.x/ast/parser/xml/internal/structure/elements.d.ts

@@ -0,0 +1,10 @@
+import { NamedXmlBasedJson, XmlBasedJson } from '../../input-format';
+import { ParserData } from '../../data';
+import { RNode } from '../../../../model';
+import { RDelimiter } from '../../../../model/nodes/info';
+export declare function splitComments(mappedWithName: NamedXmlBasedJson[]): {
+    comments: NamedXmlBasedJson[];
+    others: NamedXmlBasedJson[];
+};
+export declare function normalizeBasedOnType(data: ParserData, obj: XmlBasedJson[] | NamedXmlBasedJson[]): (RNode | RDelimiter)[];
+export declare function parseNodesWithUnknownType(data: ParserData, mappedWithName: NamedXmlBasedJson[]): (RNode | RDelimiter)[];

package/r-bridge/lang-4.x/ast/parser/xml/internal/structure/elements.js

@@ -0,0 +1,159 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.parseNodesWithUnknownType = exports.normalizeBasedOnType = exports.splitComments = void 0;
+const arrays_1 = require("../../../../../../../util/arrays");
+const parser_1 = require("../../parser");
+const meta_1 = require("../meta");
+const single_element_1 = require("./single-element");
+const values_1 = require("../values");
+const operators_1 = require("../operators");
+const loops_1 = require("../loops");
+const control_1 = require("../control");
+const log_1 = require("../../../../../../../util/log");
+const other_1 = require("../other");
+function normalizeMappedWithoutSemicolonBasedOnType(mappedWithName, data) {
+    if (mappedWithName.length === 1) {
+        return [(0, single_element_1.tryNormalizeSingleNode)(data, mappedWithName[0])];
+    }
+    else if (mappedWithName.length === 2) {
+        const unaryOp = (0, operators_1.tryNormalizeUnary)(data, mappedWithName[0], mappedWithName[1]);
+        if (unaryOp !== undefined) {
+            return [unaryOp];
+        }
+        const repeatLoop = (0, loops_1.tryNormalizeRepeat)(data, mappedWithName[0], mappedWithName[1]);
+        if (repeatLoop !== undefined) {
+            return [repeatLoop];
+        }
+    }
+    else if (mappedWithName.length === 3) {
+        const binary = (0, operators_1.tryNormalizeBinary)(data, mappedWithName[0], mappedWithName[1], mappedWithName[2]);
+        if (binary !== undefined) {
+            return [binary];
+        }
+        else {
+            const forLoop = (0, loops_1.tryNormalizeFor)(data, mappedWithName[0], mappedWithName[1], mappedWithName[2]);
+            if (forLoop !== undefined) {
+                return [forLoop];
+            }
+            else {
+                // could be a symbol with namespace information
+                const symbol = (0, values_1.tryNormalizeSymbol)(data, mappedWithName);
+                if (symbol !== undefined) {
+                    return [symbol];
+                }
+            }
+        }
+    }
+    else if (mappedWithName.length === 5) {
+        const ifThen = (0, control_1.tryNormalizeIfThen)(data, [
+            mappedWithName[0],
+            mappedWithName[1],
+            mappedWithName[2],
+            mappedWithName[3],
+            mappedWithName[4]
+        ]);
+        if (ifThen !== undefined) {
+            return [ifThen];
+        }
+        else {
+            const whileLoop = (0, loops_1.tryNormalizeWhile)(data, mappedWithName[0], mappedWithName[1], mappedWithName[2], mappedWithName[3], mappedWithName[4]);
+            if (whileLoop !== undefined) {
+                return [whileLoop];
+            }
+        }
+    }
+    else if (mappedWithName.length === 7) {
+        const ifThenElse = (0, control_1.tryNormalizeIfThenElse)(data, [
+            mappedWithName[0],
+            mappedWithName[1],
+            mappedWithName[2],
+            mappedWithName[3],
+            mappedWithName[4],
+            mappedWithName[5],
+            mappedWithName[6]
+        ]);
+        if (ifThenElse !== undefined) {
+            return [ifThenElse];
+        }
+    }
+    // otherwise perform default parsing
+    return parseNodesWithUnknownType(data, mappedWithName);
+}
+function splitComments(mappedWithName) {
+    const comments = [];
+    const others = [];
+    for (const elem of mappedWithName) {
+        if (elem.name === "COMMENT" /* RawRType.Comment */) {
+            comments.push(elem);
+        }
+        else {
+            others.push(elem);
+        }
+    }
+    return { comments, others };
+}
+exports.splitComments = splitComments;
+function normalizeBasedOnType(data, obj) {
+    if (obj.length === 0) {
+        parser_1.parseLog.warn('no children received, skipping');
+        return [];
+    }
+    let mappedWithName;
+    if (obj[0].name) {
+        mappedWithName = obj;
+    }
+    else {
+        mappedWithName = (0, meta_1.getWithTokenType)(data.config.tokenMap, obj);
+    }
+    log_1.log.trace(`[parseBasedOnType] names: [${mappedWithName.map(({ name }) => name).join(', ')}]`);
+    const semiColons = [];
+    const splitOnSemicolon = (0, arrays_1.splitArrayOn)(mappedWithName, node => {
+        const res = node.name === ";" /* RawRType.Semicolon */;
+        if (res) {
+            const { location, content } = (0, meta_1.retrieveMetaStructure)(data.config, node.content);
+            semiColons.push({
+                type: "RDelimiter" /* RType.Delimiter */,
+                subtype: ";" /* RawRType.Semicolon */,
+                location: location,
+                lexeme: content
+            });
+        }
+        return res;
+    });
+    if (splitOnSemicolon.length > 1) {
+        log_1.log.trace(`found ${splitOnSemicolon.length} expressions by semicolon-split, parsing them separately`);
+        const flattened = [];
+        for (const sub of splitOnSemicolon) {
+            const result = normalizeBasedOnType(data, sub);
+            if (result.length === 1 && result[0].type === "RExpressionList" /* RType.ExpressionList */) {
+                flattened.push(...result[0].children);
+            }
+            else {
+                flattened.push(...result);
+            }
+        }
+        return [...flattened, ...semiColons];
+    }
+    /*
+   * if splitOnSemicolon.length === 1, we can continue with the normal parsing, but we may have had a trailing semicolon, with this, it is removed as well.
+   * splitOnSemicolon.length === 0 is not possible, as we would have had an empty array before, split does not add elements.
+   */
+    mappedWithName = splitOnSemicolon[0];
+    const { comments, others } = splitComments(mappedWithName);
+    const parsedComments = comments.map(c => (0, other_1.normalizeComment)(data, c.content));
+    const result = normalizeMappedWithoutSemicolonBasedOnType(others, data);
+    // we hoist comments
+    return [...parsedComments, ...result];
+}
+exports.normalizeBasedOnType = normalizeBasedOnType;
+function parseNodesWithUnknownType(data, mappedWithName) {
+    const parsedNodes = [];
+    // used to indicate the new root node of this set of nodes
+    for (const elem of mappedWithName) {
+        const retrieved = (0, single_element_1.tryNormalizeSingleNode)(data, elem);
+        parsedNodes.push(retrieved);
+    }
+    return parsedNodes;
+}
+exports.parseNodesWithUnknownType = parseNodesWithUnknownType;
+//# sourceMappingURL=elements.js.map

package/r-bridge/lang-4.x/ast/parser/xml/internal/structure/index.d.ts

@@ -0,0 +1,3 @@
+export * from './root';
+export * from './elements';
+export * from './single-element';

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

@@ -0,0 +1,20 @@
+"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("./root"), exports);
+__exportStar(require("./elements"), exports);
+__exportStar(require("./single-element"), exports);
+//# sourceMappingURL=index.js.map

package/r-bridge/lang-4.x/ast/parser/xml/internal/structure/root.d.ts

@@ -0,0 +1,4 @@
+import { XmlBasedJson } from '../../input-format';
+import { ParserData } from '../../data';
+import { RExpressionList } from '../../../../model';
+export declare function parseRootObjToAst(data: ParserData, obj: XmlBasedJson): RExpressionList;

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

@@ -0,0 +1,34 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.parseRootObjToAst = void 0;
+const input_format_1 = require("../../input-format");
+const meta_1 = require("../meta");
+const elements_1 = require("./elements");
+const log_1 = require("../../../../../../../util/log");
+const arrays_1 = require("../../../../../../../util/arrays");
+function parseRootObjToAst(data, obj) {
+    const config = data.config;
+    const exprContent = (0, input_format_1.getKeysGuarded)(obj, "exprlist" /* RawRType.ExpressionList */);
+    (0, meta_1.assureTokenType)(config.tokenMap, exprContent, "exprlist" /* RawRType.ExpressionList */);
+    let parsedChildren = [];
+    if (config.childrenName in exprContent) {
+        const children = (0, input_format_1.getKeysGuarded)(exprContent, config.childrenName);
+        parsedChildren = (0, elements_1.normalizeBasedOnType)(data, children);
+    }
+    else {
+        log_1.log.debug('no children found, assume empty input');
+    }
+    const [delimiters, nodes] = (0, arrays_1.partition)(parsedChildren, x => x.type === "RDelimiter" /* RType.Delimiter */);
+    return {
+        type: "RExpressionList" /* RType.ExpressionList */,
+        children: nodes,
+        lexeme: undefined,
+        info: {
+            fullRange: data.currentRange,
+            additionalTokens: delimiters,
+            fullLexeme: data.currentLexeme
+        }
+    };
+}
+exports.parseRootObjToAst = parseRootObjToAst;
+//# sourceMappingURL=root.js.map

package/r-bridge/lang-4.x/ast/parser/xml/internal/structure/single-element.d.ts

@@ -0,0 +1,13 @@
+import { NamedXmlBasedJson } from '../../input-format';
+import { ParserData } from '../../data';
+import { RNode } from '../../../../model';
+import { RDelimiter } from '../../../../model/nodes/info';
+/**
+ * Parses a single structure in the ast based on its type (e.g., a string, a number, a symbol, ...)
+ *
+ * @param data - The data used by the parser (see {@link ParserData})
+ * @param elem - The element to parse
+ *
+ * @returns The parsed element as an `RNode` or an `RDelimiter` if it is such.
+ */
+export declare function tryNormalizeSingleNode(data: ParserData, elem: NamedXmlBasedJson): RNode | RDelimiter;

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

@@ -0,0 +1,64 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.tryNormalizeSingleNode = void 0;
+const input_format_1 = require("../../input-format");
+const values_1 = require("../values");
+const assert_1 = require("../../../../../../../util/assert");
+const expression_1 = require("../expression");
+const meta_1 = require("../meta");
+const other_1 = require("../other");
+const loops_1 = require("../loops");
+const line_directive_1 = require("../other/line-directive");
+function normalizeDelimiter(data, elem) {
+    const { location, content } = (0, meta_1.retrieveMetaStructure)(data.config, elem.content);
+    return {
+        type: "RDelimiter" /* RType.Delimiter */,
+        location,
+        lexeme: content,
+        subtype: elem.name
+    };
+}
+/**
+ * Parses a single structure in the ast based on its type (e.g., a string, a number, a symbol, ...)
+ *
+ * @param data - The data used by the parser (see {@link ParserData})
+ * @param elem - The element to parse
+ *
+ * @returns The parsed element as an `RNode` or an `RDelimiter` if it is such.
+ */
+function tryNormalizeSingleNode(data, elem) {
+    switch (elem.name) {
+        case "(" /* RawRType.ParenLeft */:
+        case ")" /* RawRType.ParenRight */:
+        case "{" /* RawRType.BraceLeft */:
+        case "}" /* RawRType.BraceRight */:
+            return normalizeDelimiter(data, elem);
+        case "COMMENT" /* RawRType.Comment */:
+            return (0, other_1.normalizeComment)(data, elem.content);
+        case "LINE_DIRECTIVE" /* RawRType.LineDirective */:
+            return (0, line_directive_1.normalizeLineDirective)(data, elem.content);
+        case "exprlist" /* RawRType.ExpressionList */:
+        case "expr" /* RawRType.Expression */:
+        case "expr_or_assign_or_help" /* RawRType.ExprOfAssignOrHelp */:
+            return (0, expression_1.normalizeExpression)(data, elem.content);
+        case "NUM_CONST" /* RawRType.NumericConst */:
+            return (0, values_1.normalizeNumber)(data, elem.content);
+        case "STR_CONST" /* RawRType.StringConst */:
+            return (0, values_1.normalizeString)(data, elem.content);
+        case "BREAK" /* RawRType.Break */:
+            return (0, loops_1.normalizeBreak)(data, elem.content);
+        case "NEXT" /* RawRType.Next */:
+            return (0, loops_1.normalizeNext)(data, elem.content);
+        case "SYMBOL" /* RawRType.Symbol */:
+        case "SLOT" /* RawRType.Slot */:
+        case "NULL_CONST" /* RawRType.NullConst */: {
+            const symbol = (0, values_1.tryNormalizeSymbol)(data, (0, meta_1.getWithTokenType)(data.config.tokenMap, [elem.content]));
+            (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 ${elem.name} for ${JSON.stringify(elem)} in ${JSON.stringify(data)}`);
+    }
+}
+exports.tryNormalizeSingleNode = tryNormalizeSingleNode;
+//# sourceMappingURL=single-element.js.map

package/r-bridge/lang-4.x/ast/parser/xml/internal/values/index.d.ts

@@ -0,0 +1,3 @@
+export * from './number';
+export * from './string';
+export * from './symbol';

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

@@ -0,0 +1,20 @@
+"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);
+__exportStar(require("./string"), exports);
+__exportStar(require("./symbol"), exports);
+//# sourceMappingURL=index.js.map

package/r-bridge/lang-4.x/ast/parser/xml/internal/values/number.d.ts

@@ -0,0 +1,13 @@
+import { XmlBasedJson } from '../../input-format';
+import { RNa } from '../../../../../values';
+import { RLogical, RSymbol, NoInfo, RNumber } from '../../../../model';
+import { ParserData } from '../../data';
+/**
+ * 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 data - The data used by the parser (see {@link ParserData})
+ * @param obj  - The json object to extract the meta-information from
+ */
+export declare function normalizeNumber(data: ParserData, obj: XmlBasedJson): RNumber | RLogical | RSymbol<NoInfo, typeof RNa>;

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

@@ -0,0 +1,56 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.normalizeNumber = void 0;
+const values_1 = require("../../../../../values");
+const parser_1 = require("../../parser");
+const meta_1 = require("../meta");
+const hooks_1 = require("../../hooks");
+/**
+ * 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 data - The data used by the parser (see {@link ParserData})
+ * @param obj  - The json object to extract the meta-information from
+ */
+function normalizeNumber(data, obj) {
+    parser_1.parseLog.debug('[number]');
+    obj = (0, hooks_1.executeHook)(data.hooks.values.onNumber.before, data, obj);
+    const { location, content } = (0, meta_1.retrieveMetaStructure)(data.config, obj);
+    const common = {
+        location,
+        lexeme: content,
+        info: {
+            fullRange: data.currentRange,
+            additionalTokens: [],
+            fullLexeme: data.currentLexeme
+        }
+    };
+    let result;
+    /* the special symbol */
+    if ((0, values_1.isNA)(content)) {
+        result = {
+            ...common,
+            namespace: undefined,
+            type: "RSymbol" /* RType.Symbol */,
+            content
+        };
+    }
+    else if ((0, values_1.isBoolean)(content)) {
+        result = {
+            ...common,
+            type: "RLogical" /* RType.Logical */,
+            content: (0, values_1.boolean2ts)(content)
+        };
+    }
+    else {
+        result = {
+            ...common,
+            type: "RNumber" /* RType.Number */,
+            content: (0, values_1.number2ts)(content)
+        };
+    }
+    return (0, hooks_1.executeHook)(data.hooks.values.onNumber.after, data, result);
+}
+exports.normalizeNumber = normalizeNumber;
+//# sourceMappingURL=number.js.map

package/r-bridge/lang-4.x/ast/parser/xml/internal/values/string.d.ts

@@ -0,0 +1,11 @@
+import { XmlBasedJson } from '../../input-format';
+import { RString } from '../../../../model';
+import { ParserData } from '../../data';
+/**
+ * Normalize the given object as a R string (see {@link string2ts}).
+ * This requires you to check the corresponding name beforehand.
+ *
+ * @param data - The data used by the parser (see {@link ParserData})
+ * @param obj  - The json object to extract the meta-information from
+ */
+export declare function normalizeString(data: ParserData, obj: XmlBasedJson): RString;

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

@@ -0,0 +1,41 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.normalizeString = void 0;
+const meta_1 = require("../meta");
+const values_1 = require("../../../../../values");
+const parser_1 = require("../../parser");
+const hooks_1 = require("../../hooks");
+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 data - The data used by the parser (see {@link ParserData})
+ * @param obj  - The json object to extract the meta-information from
+ */
+function normalizeString(data, obj) {
+    parser_1.parseLog.debug('[string]');
+    obj = (0, hooks_1.executeHook)(data.hooks.values.onString.before, data, obj);
+    const { location, content } = (0, meta_1.retrieveMetaStructure)(data.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 '"']"
+        (0, assert_1.guard)(data.currentLexeme !== undefined, 'need current lexeme wrapper for too long strings as they are not stored by the R parser post-processor');
+        stringContent = data.currentLexeme;
+    }
+    const result = {
+        type: "RString" /* RType.String */,
+        location,
+        content: (0, values_1.string2ts)(stringContent),
+        lexeme: stringContent,
+        info: {
+            fullRange: data.currentRange,
+            additionalTokens: [],
+            fullLexeme: data.currentLexeme
+        }
+    };
+    return (0, hooks_1.executeHook)(data.hooks.values.onString.after, data, result);
+}
+exports.normalizeString = normalizeString;
+//# sourceMappingURL=string.js.map

package/r-bridge/lang-4.x/ast/parser/xml/internal/values/symbol.d.ts

@@ -0,0 +1,14 @@
+import { NamedXmlBasedJson } from '../../input-format';
+import { RSymbol } from '../../../../model';
+import { ParserData } from '../../data';
+/**
+ * Normalize the given object as an R symbol (incorporating namespace information).
+ * <p>
+ * The special symbols `T` and `F` are parsed as logic values.
+ *
+ * @param data - The data used by the parser (see {@link ParserData})
+ * @param objs - The json object to extract the meta-information from
+ *
+ * @returns The parsed symbol (with populated namespace information) or `undefined` if the given object is not a symbol.
+ */
+export declare function tryNormalizeSymbol(data: ParserData, objs: NamedXmlBasedJson[]): RSymbol | undefined;

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

@@ -0,0 +1,56 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.tryNormalizeSymbol = void 0;
+const assert_1 = require("../../../../../../../util/assert");
+const meta_1 = require("../meta");
+const parser_1 = require("../../parser");
+const model_1 = require("../../../../model");
+const hooks_1 = require("../../hooks");
+const strings_1 = require("../../../../../../../util/strings");
+/**
+ * Normalize the given object as an R symbol (incorporating namespace information).
+ * <p>
+ * The special symbols `T` and `F` are parsed as logic values.
+ *
+ * @param data - The data used by the parser (see {@link ParserData})
+ * @param objs - The json object to extract the meta-information from
+ *
+ * @returns The parsed symbol (with populated namespace information) or `undefined` if the given object is not a symbol.
+ */
+function tryNormalizeSymbol(data, objs) {
+    (0, assert_1.guard)(objs.length > 0, 'to parse symbols we need at least one object to work on!');
+    parser_1.parseLog.debug('trying to parse symbol');
+    objs = (0, hooks_1.executeHook)(data.hooks.values.onSymbol.before, data, objs);
+    let location, content, namespace;
+    if (objs.length === 1 && (0, model_1.isSymbol)(objs[0].name)) {
+        const meta = (0, meta_1.retrieveMetaStructure)(data.config, objs[0].content);
+        location = meta.location;
+        content = meta.content;
+        namespace = undefined;
+    }
+    else if (objs.length === 3 && (0, model_1.isSymbol)(objs[2].name)) {
+        const meta = (0, meta_1.retrieveMetaStructure)(data.config, objs[2].content);
+        location = meta.location;
+        content = meta.content;
+        namespace = (0, meta_1.retrieveMetaStructure)(data.config, objs[0].content).content;
+    }
+    else {
+        return (0, hooks_1.executeUnknownHook)(data.hooks.values.onSymbol.unknown, data, objs);
+    }
+    const result = {
+        type: "RSymbol" /* RType.Symbol */,
+        namespace,
+        location,
+        // remove backticks from symbol
+        content: (0, strings_1.startAndEndsWith)(content, '`') ? content.substring(1, content.length - 1) : content,
+        lexeme: content,
+        info: {
+            fullRange: data.currentRange,
+            additionalTokens: [],
+            fullLexeme: data.currentLexeme
+        }
+    };
+    return (0, hooks_1.executeHook)(data.hooks.values.onSymbol.after, data, result);
+}
+exports.tryNormalizeSymbol = tryNormalizeSymbol;
+//# sourceMappingURL=symbol.js.map

package/r-bridge/lang-4.x/ast/parser/xml/internal/xml-to-json.d.ts

@@ -0,0 +1,9 @@
+import { XmlParserConfig } from '../config';
+import { XmlBasedJson } from '../input-format';
+/**
+ * Parse the xml presented by R into a json object that will be used for conversion
+ *
+ * @param config    - The configuration to use (i.e., what names should be used for the attributes, children, ...)
+ * @param xmlString - The xml input to parse
+ */
+export declare function xlm2jsonObject(config: XmlParserConfig, xmlString: string): Promise<XmlBasedJson>;

package/r-bridge/lang-4.x/ast/parser/xml/internal/xml-to-json.js

@@ -0,0 +1,51 @@
+"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 __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || function (mod) {
+    if (mod && mod.__esModule) return mod;
+    var result = {};
+    if (mod != null) for (var k in mod) if (k !== "default" && Object.prototype.hasOwnProperty.call(mod, k)) __createBinding(result, mod, k);
+    __setModuleDefault(result, mod);
+    return result;
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.xlm2jsonObject = void 0;
+const xml2js = __importStar(require("xml2js"));
+/**
+ * Parse the xml presented by R into a json object that will be used for conversion
+ *
+ * @param config    - The configuration to use (i.e., what names should be used for the attributes, children, ...)
+ * @param xmlString - The xml input to parse
+ */
+function xlm2jsonObject(config, xmlString) {
+    return xml2js.parseStringPromise(xmlString, {
+        attrkey: config.attributeName,
+        charkey: config.contentName,
+        childkey: config.childrenName,
+        charsAsChildren: false,
+        explicitChildren: true,
+        mergeAttrs: false,
+        // we need this for semicolons etc., while we keep the old broken components we ignore them completely
+        preserveChildrenOrder: true,
+        trim: true,
+        includeWhiteChars: true,
+        normalize: false,
+        strict: true
+    });
+}
+exports.xlm2jsonObject = xlm2jsonObject;
+//# sourceMappingURL=xml-to-json.js.map

package/r-bridge/lang-4.x/ast/parser/xml/parser.d.ts

@@ -0,0 +1,17 @@
+import { NormalizedAst, IdGenerator, NoInfo } from '../../model';
+import { XmlParserHooks } from './hooks';
+import { DeepPartial } from 'ts-essentials';
+import { TokenMap } from '../../../../retriever';
+export declare const parseLog: import("tslog").Logger<import("tslog").ILogObj>;
+/**
+ * The main entry point to normalize the given R ast.
+ * You probably want to use {@link retrieveNormalizedAstFromRCode} to directly normalize a piece of code.
+ *
+ * @param xmlString - The XML string obtained probably by {@link retrieveXmlFromRCode} for normalization.
+ * @param tokenMap  - The token replacement map in effect by the XML parser
+ * @param hooks     - Optional hooks to customize the normalization process (see {@link XmlParserHooks} for details)
+ * @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)
+ */
+export declare function normalize(xmlString: string, tokenMap: TokenMap, hooks?: DeepPartial<XmlParserHooks>, getId?: IdGenerator<NoInfo>): Promise<NormalizedAst>;

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

@@ -0,0 +1,30 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.normalize = exports.parseLog = void 0;
+const objects_1 = require("../../../../../util/objects");
+const log_1 = require("../../../../../util/log");
+const config_1 = require("./config");
+const internal_1 = require("./internal");
+const model_1 = require("../../model");
+const hooks_1 = require("./hooks");
+exports.parseLog = log_1.log.getSubLogger({ name: 'ast-parser' });
+/**
+ * The main entry point to normalize the given R ast.
+ * You probably want to use {@link retrieveNormalizedAstFromRCode} to directly normalize a piece of code.
+ *
+ * @param xmlString - The XML string obtained probably by {@link retrieveXmlFromRCode} for normalization.
+ * @param tokenMap  - The token replacement map in effect by the XML parser
+ * @param hooks     - Optional hooks to customize the normalization process (see {@link XmlParserHooks} for details)
+ * @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, hooks, getId = (0, model_1.deterministicCountingIdGenerator)(0)) {
+    const config = { ...config_1.DEFAULT_XML_PARSER_CONFIG, tokenMap };
+    const hooksWithDefaults = (0, objects_1.deepMergeObject)(hooks_1.DEFAULT_PARSER_HOOKS, hooks);
+    const data = { config, hooks: hooksWithDefaults, currentRange: undefined, currentLexeme: undefined };
+    const object = await (0, internal_1.xlm2jsonObject)(config, xmlString);
+    return (0, model_1.decorateAst)((0, internal_1.parseRootObjToAst)(data, object), getId);
+}
+exports.normalize = normalize;
+//# sourceMappingURL=parser.js.map

package/r-bridge/lang-4.x/ast/parser/xml/v1/data.js

@@ -0,0 +1,3 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+//# sourceMappingURL=data.js.map