@eagleoutice/flowr 1.3.11

package/r-bridge/lang-4.x/ast/parser/xml/v1/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/v1/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 normalize_1 = require("../../normalize");
+const meta_1 = require("../../../common/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) {
+    normalize_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/v1/internal/values/string.js

@@ -0,0 +1,41 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.normalizeString = void 0;
+const meta_1 = require("../../../common/meta");
+const values_1 = require("../../../../../../values");
+const normalize_1 = require("../../normalize");
+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) {
+    normalize_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/v1/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("../../../common/meta");
+const normalize_1 = require("../../normalize");
+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!');
+    normalize_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/v1/normalize.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("../common/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.normalizeRootObjToAst)(data, object), getId);
+}
+exports.normalize = normalize;
+//# sourceMappingURL=normalize.js.map

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

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

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

@@ -0,0 +1,95 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.normalizeAccess = void 0;
+const input_format_1 = require("../../common/input-format");
+const meta_1 = require("../../common/meta");
+const assert_1 = require("../../../../../../../util/assert");
+const arrays_1 = require("../../../../../../../util/arrays");
+const single_element_1 = require("./single-element");
+const argument_1 = require("./functions/argument");
+/**
+ * Normalize the given data as access (e.g., indexing).
+ *
+ * @param configuration - The data used by the parser (see {@link NormalizeConfiguration})
+ * @param tokens        - The json object to extract the meta-information from
+ * @param accessType    - The type of the access (e.g., `[[` or `$`)
+ *
+ * @returns The parsed {@link RAccess} or `undefined` if the given construct is not accessing a value
+ */
+function normalizeAccess(configuration, tokens, accessType) {
+    let closingLength = 0;
+    // TODO: shorthand combinations like `[<-` or `$<-`
+    switch (accessType) {
+        case "$" /* RawRType.Dollar */:
+        case "@" /* RawRType.At */:
+            break;
+        case "[" /* RawRType.BracketLeft */:
+            closingLength = 1;
+            break;
+        case "LBB" /* RawRType.DoubleBracketLeft */:
+            closingLength = 2;
+            break;
+        default:
+            throw new input_format_1.XmlParseError(`expected second element to be an access operator, yet received ${accessType}`);
+    }
+    const first = (0, meta_1.getTokenType)(configuration.tokenMap, tokens[0]);
+    (0, assert_1.guard)(first === "expr" /* RawRType.Expression */ || first === "expr_or_assign_or_help" /* RawRType.ExprOfAssignOrHelp */, () => `expected accessed element to be wrapped an expression, yet received ${first}`);
+    const parsedAccessed = (0, single_element_1.normalizeSingleToken)(configuration, tokens[0]);
+    const { content, location } = (0, meta_1.retrieveMetaStructure)(configuration, tokens[1]);
+    // we can handle $ and @ directly
+    if (closingLength === 0) {
+        return {
+            type: "RFunctionCall" /* RType.FunctionCall */,
+            location,
+            lexeme: content,
+            info: {},
+            flavor: 'named',
+            functionName: {
+                type: "RSymbol" /* RType.Symbol */,
+                // TODO: just lock "internal" here
+                namespace: undefined,
+                lexeme: content,
+                info: {},
+                content,
+                location
+            },
+            arguments: [
+                parsedAccessed,
+                // normalize the symbol following
+                (0, single_element_1.normalizeSingleToken)(configuration, tokens[2])
+            ],
+        };
+    }
+    // otherwise we have to process
+    const remaining = tokens.slice(2, tokens.length - closingLength);
+    const splitAccessOnComma = (0, arrays_1.splitArrayOn)(remaining, elem => elem.name === "," /* RawRType.Comma */);
+    const parsedAccess = splitAccessOnComma.map((elems) => elems.length === 0 ? undefined : normalizeAccessArgument(configuration, elems));
+    return {
+        type: "RFunctionCall" /* RType.FunctionCall */,
+        location,
+        lexeme: content,
+        info: {},
+        flavor: 'named',
+        functionName: {
+            type: "RSymbol" /* RType.Symbol */,
+            // TODO: just lock "internal" here
+            namespace: undefined,
+            lexeme: content,
+            info: {},
+            content,
+            location
+        },
+        arguments: [
+            parsedAccessed,
+            // normalize the symbol following
+            ...parsedAccess
+        ],
+    };
+}
+exports.normalizeAccess = normalizeAccess;
+function normalizeAccessArgument(config, elements) {
+    const res = (0, argument_1.tryToNormalizeArgument)(config, elements);
+    (0, assert_1.guard)(res !== undefined, () => `expected one access result in access as argument, yet received ${JSON.stringify(res)} for ${JSON.stringify(elements)}`);
+    return res;
+}
+//# sourceMappingURL=access.js.map

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

@@ -0,0 +1,99 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.normalizeExpression = void 0;
+const normalize_1 = require("../normalize");
+const log_1 = require("../../../../../../../util/log");
+const xml_to_json_1 = require("../../common/xml-to-json");
+const single_element_1 = require("./single-element");
+const operators_1 = require("./operators");
+const symbol_1 = require("./values/symbol");
+const meta_1 = require("../../common/meta");
+const access_1 = require("./access");
+function handleSemicolons(tokens) {
+    let last = 0, i = 0;
+    const segments = [];
+    for (const token of tokens) {
+        if (token[xml_to_json_1.XML_NAME] === ";" /* RawRType.Semicolon */) {
+            segments.push(tokens.slice(last, i++));
+            last = i + 1;
+        }
+    }
+    if (last < tokens.length) {
+        segments.push(tokens.slice(last, tokens.length));
+    }
+    return segments;
+}
+// TODO: guard with and without semicolon?
+function normalizeExpression(config, tokens) {
+    if (tokens.length === 0) {
+        // if there are no tokens, there is no expression to parse, and we can skip it!
+        return [];
+    }
+    (0, log_1.expensiveTrace)(normalize_1.normalizeLog, () => `[expr] ${tokens.map(x => x[xml_to_json_1.XML_NAME]).join(', ')}`);
+    if (tokens.length > 1) {
+        // iterate over types, find all semicolons, and segment the tokens based on them.
+        // we could potentially optimize as not all expr may have semicolons but not for now
+        const segments = handleSemicolons(tokens);
+        if (segments.length > 1) {
+            normalize_1.normalizeLog.trace(`found ${segments.length} ';' segments`);
+            return segments.flatMap(segment => normalizeExpression(config, segment));
+        }
+        /*
+         * 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.
+         */
+        tokens = segments[0];
+    }
+    // const types = tokens.map(x => x[XML_NAME] as string)
+    return [normalizeElems(config, tokens)];
+}
+exports.normalizeExpression = normalizeExpression;
+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 constant, function call, symbol, ...)
+ * @param config - The data used to normalize (see {@link NormalizeConfiguration})
+ * @param tokens - The non-empty list of tokens to parse
+ */
+function normalizeElems(config, tokens) {
+    const length = tokens.length;
+    if (length === 1) {
+        return (0, single_element_1.normalizeSingleToken)(config, tokens[0]);
+    }
+    else if (length === 2) {
+        return (0, operators_1.normalizeUnary)(config, tokens);
+    }
+    // otherwise, before we check for fixed-length constructs we have to check for the *second* element
+    // in case we have a function-call, access, ...
+    const second = (0, meta_1.getTokenType)(config.tokenMap, tokens[1]);
+    // TODO: use internal functions directly and not named if they can not be overwritten!
+    switch (second) {
+        case "(" /* RawRType.ParenLeft */:
+            return todo(tokens);
+        case "$" /* RawRType.Dollar */:
+        case "@" /* RawRType.At */:
+        case "[" /* RawRType.BracketLeft */:
+        case "LBB" /* RawRType.DoubleBracketLeft */:
+            return (0, access_1.normalizeAccess)(config, tokens, second);
+    }
+    switch (length) {
+        case 3: // TODO: for
+            return (0, symbol_1.tryNormalizeSymbolWithNamespace)(config, tokens)
+                ?? (0, operators_1.tryNormalizeBinary)(config, tokens);
+        case 5:
+            return todo(tokens);
+        case 7:
+            return todo(tokens);
+        default:
+            return todo(tokens);
+    }
+}
+/*export function parseNodesWithUnknownType(data: ParserData, mappedWithName: NamedXmlBasedJson[]): (RNode | RDelimiter)[] {
+    const parsedNodes: (RNode | RDelimiter)[] = []
+    // used to indicate the new root node of this set of nodes
+    for(const elem of mappedWithName) {
+        const retrieved = tryNormalizeSingleNode(data, elem)
+        parsedNodes.push(retrieved)
+    }
+    return parsedNodes
+}*/
+//# sourceMappingURL=expression.js.map

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

@@ -0,0 +1,71 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.tryToNormalizeArgument = void 0;
+const input_format_1 = require("../../../common/input-format");
+const meta_1 = require("../../../common/meta");
+const log_1 = require("../../../../../../../../util/log");
+const assert_1 = require("../../../../../../../../util/assert");
+const single_element_1 = require("../single-element");
+/**
+ * Either parses `[expr]` or `[SYMBOL_SUB, EQ_SUB, expr]` as an argument of a function call in R.
+ * Probably directly called by the function call parser as otherwise, we do not expect to find arguments.
+ *
+ * @param configuration - The data used for the normalization (see {@link NormalizeConfiguration})
+ * @param objs - Either `[expr]` or `[SYMBOL_FORMALS, EQ_FORMALS, expr]`
+ *
+ * @returns The parsed argument or `undefined` if the given object is not an argument.
+ */
+function tryToNormalizeArgument(configuration, objs) {
+    if (objs.length < 1 || objs.length > 3) {
+        log_1.log.warn(`Either [expr|value], [SYMBOL_SUB, EQ_SUB], or [SYMBOL_SUB, EQ_SUB, expr], but got: ${objs.map(o => JSON.stringify(o)).join(', ')}`);
+        return undefined;
+    }
+    const [first] = objs;
+    const symbolOrExpr = (0, meta_1.getTokenType)(configuration.tokenMap, first);
+    const { location, content } = (0, meta_1.retrieveMetaStructure)(configuration, first);
+    let parsedValue;
+    let name;
+    if (symbolOrExpr === "expr" /* RawRType.Expression */) {
+        name = undefined;
+        parsedValue = (0, single_element_1.normalizeSingleToken)(configuration, first);
+    }
+    else if (symbolOrExpr === "SYMBOL_SUB" /* RawRType.SymbolSub */ || symbolOrExpr === "STR_CONST" /* RawRType.StringConst */) {
+        name = {
+            type: "RSymbol" /* RType.Symbol */,
+            location,
+            content: symbolOrExpr === "STR_CONST" /* RawRType.StringConst */ ? content.slice(1, -1) : content,
+            namespace: undefined,
+            lexeme: content,
+            info: {
+                fullRange: location,
+                additionalTokens: [],
+                fullLexeme: content
+            }
+        };
+        parsedValue = normalizeWithValue(configuration, objs);
+    }
+    else {
+        throw new input_format_1.XmlParseError(`expected symbol or expr for argument, yet received ${objs.map(o => JSON.stringify(o)).join(',')}`);
+    }
+    (0, assert_1.guard)(parsedValue !== undefined && parsedValue?.type !== "RDelimiter" /* RType.Delimiter */, () => `[argument] parsed value must not be undefined, yet: ${JSON.stringify(objs)}`);
+    return {
+        type: "RArgument" /* RType.Argument */,
+        location,
+        lexeme: content,
+        name,
+        value: parsedValue ?? undefined,
+        info: {
+            fullRange: location,
+            fullLexeme: content,
+            additionalTokens: []
+        }
+    };
+}
+exports.tryToNormalizeArgument = tryToNormalizeArgument;
+function normalizeWithValue(data, [fst, eq, lst]) {
+    const eqType = (0, meta_1.getTokenType)(data.tokenMap, eq);
+    (0, assert_1.guard)(eqType === "EQ_SUB" /* RawRType.EqualSub */, () => `[arg-default] second element of parameter must be ${"EQ_FORMALS" /* RawRType.EqualFormals */}, but: ${JSON.stringify([fst, eq, lst])}`);
+    (0, assert_1.guard)(lst === undefined || (0, meta_1.getTokenType)(data.tokenMap, lst) === "expr" /* RawRType.Expression */, () => `[arg-default] third element of parameter must be an Expression or undefined (for 'x=') but: ${JSON.stringify([fst, eq, lst])}`);
+    return lst ? (0, single_element_1.normalizeSingleToken)(data, lst) : null;
+}
+//# sourceMappingURL=argument.js.map

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

@@ -0,0 +1,30 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.tryNormalizeBinary = void 0;
+const meta_1 = require("../../../common/meta");
+const single_element_1 = require("../single-element");
+/**
+ * Parsing binary operations includes the pipe, even though the produced PIPE construct is not a binary operation,
+ * to ensure it is handled separately from the others (especially in the combination of a pipe bind)
+ */
+function tryNormalizeBinary(config, [lhs, operator, rhs]) {
+    const { location, content } = (0, meta_1.retrieveMetaStructure)(config, operator);
+    return {
+        type: "RFunctionCall" /* RType.FunctionCall */,
+        lexeme: config.currentLexeme ?? content,
+        location,
+        flavor: 'named',
+        functionName: {
+            type: "RSymbol" /* RType.Symbol */,
+            namespace: undefined,
+            location,
+            content,
+            lexeme: content,
+            info: {}
+        },
+        arguments: [(0, single_element_1.normalizeSingleToken)(config, lhs), (0, single_element_1.normalizeSingleToken)(config, rhs)],
+        info: {}
+    };
+}
+exports.tryNormalizeBinary = tryNormalizeBinary;
+//# sourceMappingURL=binary.js.map

package/r-bridge/lang-4.x/ast/parser/xml/v2/internal/operators/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("./unary"), exports);
+__exportStar(require("./binary"), exports);
+//# sourceMappingURL=index.js.map

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

@@ -0,0 +1,35 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.normalizeUnary = void 0;
+const meta_1 = require("../../../common/meta");
+const single_element_1 = require("../single-element");
+/**
+ * Parses the construct as a unary op.
+ *
+ * @param config   - The normalizer config
+ * @param operator - The operator token
+ * @param operand  - The operand of the unary operator
+ *
+ * @returns The parsed unary op function call
+ */
+function normalizeUnary(config, [operator, operand]) {
+    const { location, content } = (0, meta_1.retrieveMetaStructure)(config, operator);
+    return {
+        type: "RFunctionCall" /* RType.FunctionCall */,
+        lexeme: config.currentLexeme ?? content,
+        location,
+        flavor: 'named',
+        functionName: {
+            type: "RSymbol" /* RType.Symbol */,
+            namespace: undefined,
+            location,
+            content,
+            lexeme: content,
+            info: {}
+        },
+        arguments: [(0, single_element_1.normalizeSingleToken)(config, operand)],
+        info: {}
+    };
+}
+exports.normalizeUnary = normalizeUnary;
+//# sourceMappingURL=unary.js.map

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

@@ -0,0 +1,25 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.normalizeComment = void 0;
+const meta_1 = require("../../../common/meta");
+/**
+ * Normalize the given object as an R comment.
+ * This requires you to check the corresponding name beforehand.
+ *
+ * @param config - The normalizer config to use
+ * @param obj  - The json object to extract the meta-information from
+ */
+function normalizeComment(config, obj) {
+    const { location, content } = (0, meta_1.retrieveMetaStructure)(config, obj);
+    // we trust the parser here
+    // guard(content.startsWith ('#'), 'comment must start with #')
+    return {
+        type: "RComment" /* RType.Comment */,
+        location,
+        content: content.slice(1),
+        lexeme: content,
+        info: {}
+    };
+}
+exports.normalizeComment = normalizeComment;
+//# sourceMappingURL=comment.js.map

package/r-bridge/lang-4.x/ast/parser/xml/v2/internal/other/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("./comment"), exports);
+//# sourceMappingURL=index.js.map

package/r-bridge/lang-4.x/ast/parser/xml/v2/internal/other/line-directive.js

@@ -0,0 +1,38 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.normalizeLineDirective = void 0;
+const meta_1 = require("../../../common/meta");
+const LineDirectiveRegex = /^#line\s+(\d+)\s+"([^"]+)"\s*$/;
+/**
+ * Normalize the given object as an R line directive (`#line <number> "<file>"`).
+ * This requires you to check the corresponding name beforehand.
+ * If the given object turns out to be no line directive, this returns a normal comment instead.
+ *
+ * @param config - The normalizer config to use
+ * @param obj  - The json object to extract the meta-information from
+ */
+function normalizeLineDirective(config, obj) {
+    const { location, content } = (0, meta_1.retrieveMetaStructure)(config, obj);
+    const match = LineDirectiveRegex.exec(content);
+    if (match === null) {
+        return {
+            type: "RComment" /* RType.Comment */,
+            location,
+            content: content.slice(1),
+            lexeme: content,
+            info: {}
+        };
+    }
+    else {
+        return {
+            type: "RLineDirective" /* RType.LineDirective */,
+            location,
+            line: parseInt(match[1]),
+            file: match[2],
+            lexeme: content,
+            info: {}
+        };
+    }
+}
+exports.normalizeLineDirective = normalizeLineDirective;
+//# sourceMappingURL=line-directive.js.map