@eagleoutice/flowr 1.3.11

package/r-bridge/lang-4.x/ast/parser/xml/v1/internal/functions/call.js

@@ -0,0 +1,149 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.tryNormalizeFunctionCall = void 0;
+const input_format_1 = require("../../../common/input-format");
+const assert_1 = require("../../../../../../../../util/assert");
+const meta_1 = require("../../../common/meta");
+const arrays_1 = require("../../../../../../../../util/arrays");
+const normalize_1 = require("../../normalize");
+const values_1 = require("../values");
+const hooks_1 = require("../../hooks");
+const argument_1 = require("./argument");
+const expression_1 = require("../expression");
+/**
+ * Tries to parse the given data as a function call.
+ *
+ * @param data           - The data used by the parser (see {@link ParserData})
+ * @param mappedWithName - The json object to extract the meta-information from
+ *
+ * @returns The parsed {@link RFunctionCall} (either named or unnamed) or `undefined` if the given construct is not a function call
+ * May return a {@link RNext} or {@link RBreak} as `next()` and `break()` work as such.
+ */
+function tryNormalizeFunctionCall(data, mappedWithName) {
+    const fnBase = mappedWithName[0];
+    if (fnBase.name !== "expr" /* RawRType.Expression */ && fnBase.name !== "expr_or_assign_or_help" /* RawRType.ExprOfAssignOrHelp */) {
+        normalize_1.parseLog.trace(`expected function call name to be wrapped an expression, yet received ${fnBase.name}`);
+        return (0, hooks_1.executeUnknownHook)(data.hooks.functions.onFunctionCall.unknown, data, mappedWithName);
+    }
+    if (mappedWithName.length < 3 || mappedWithName[1].name !== "(" /* RawRType.ParenLeft */ || mappedWithName[mappedWithName.length - 1].name !== ")" /* RawRType.ParenRight */) {
+        normalize_1.parseLog.trace('expected function call to have parenthesis for a call, but was not');
+        return undefined;
+    }
+    normalize_1.parseLog.trace('trying to parse function call');
+    mappedWithName = (0, hooks_1.executeHook)(data.hooks.functions.onFunctionCall.before, data, mappedWithName);
+    const { unwrappedObj, content, location } = (0, meta_1.retrieveMetaStructure)(data.config, fnBase.content);
+    const symbolContent = (0, input_format_1.getKeyGuarded)(unwrappedObj, data.config.children);
+    let result;
+    const namedSymbolContent = (0, meta_1.getWithTokenType)(data.config.tokenMap, symbolContent);
+    if (namedSymbolContent.length === 1 && namedSymbolContent[0].name === "STR_CONST" /* RawRType.StringConst */) {
+        // special handling when someone calls a function by string
+        result = parseNamedFunctionCall(data, namedSymbolContent, mappedWithName, location, content);
+    }
+    else if (namedSymbolContent.findIndex(x => x.name === "SYMBOL_FUNCTION_CALL" /* RawRType.SymbolFunctionCall */) < 0) {
+        normalize_1.parseLog.trace(`is not named function call, as the name is not of type ${"RFunctionCall" /* RType.FunctionCall */}, but: ${namedSymbolContent.map(n => n.name).join(',')}`);
+        const mayResult = tryParseUnnamedFunctionCall(data, mappedWithName, location, content);
+        if (mayResult === undefined) {
+            return (0, hooks_1.executeUnknownHook)(data.hooks.functions.onFunctionCall.unknown, data, mappedWithName);
+        }
+        result = mayResult;
+    }
+    else {
+        result = parseNamedFunctionCall(data, namedSymbolContent, mappedWithName, location, content);
+    }
+    return (0, hooks_1.executeHook)(data.hooks.functions.onFunctionCall.after, data, result);
+}
+exports.tryNormalizeFunctionCall = tryNormalizeFunctionCall;
+function parseArguments(mappedWithName, data) {
+    const argContainer = mappedWithName.slice(1);
+    (0, assert_1.guard)(argContainer.length > 1 && argContainer[0].name === "(" /* RawRType.ParenLeft */ && argContainer[argContainer.length - 1].name === ")" /* RawRType.ParenRight */, 'expected args in parenthesis');
+    const splitArgumentsOnComma = (0, arrays_1.splitArrayOn)(argContainer.slice(1, argContainer.length - 1), x => x.name === "," /* RawRType.Comma */);
+    return splitArgumentsOnComma.map(x => {
+        normalize_1.parseLog.trace('trying to parse argument');
+        return (0, argument_1.tryToNormalizeArgument)(data, x);
+    });
+}
+function tryParseUnnamedFunctionCall(data, mappedWithName, location, content) {
+    // maybe remove symbol-content again because I just use the root expr of mapped with name
+    if (mappedWithName.length < 3) {
+        normalize_1.parseLog.trace('expected unnamed function call to have 3 elements [like (<func>)], but was not');
+        return undefined;
+    }
+    normalize_1.parseLog.trace('Assuming structure to be a function call');
+    // we parse an expression to allow function calls
+    const calledFunction = (0, expression_1.normalizeExpression)(data, mappedWithName[0].content);
+    const parsedArguments = parseArguments(mappedWithName, data);
+    if (parsedArguments.length === 0) {
+        // sadly, next() and break() work
+        if (calledFunction.type === "RNext" /* RType.Next */) {
+            return {
+                type: "RNext" /* RType.Next */,
+                lexeme: content,
+                location,
+                info: {
+                    fullRange: data.currentRange,
+                    additionalTokens: [],
+                    fullLexeme: data.currentLexeme
+                }
+            };
+        }
+        else if (calledFunction.type === "RBreak" /* RType.Break */) {
+            return {
+                type: "RBreak" /* RType.Break */,
+                lexeme: content,
+                location,
+                info: {
+                    fullRange: data.currentRange,
+                    additionalTokens: [],
+                    fullLexeme: data.currentLexeme
+                }
+            };
+        }
+    }
+    return {
+        type: "RFunctionCall" /* RType.FunctionCall */,
+        flavor: 'unnamed',
+        location,
+        lexeme: content,
+        calledFunction: calledFunction,
+        arguments: parsedArguments,
+        info: {
+            fullRange: data.currentRange,
+            additionalTokens: [],
+            fullLexeme: data.currentLexeme
+        }
+    };
+}
+function parseNamedFunctionCall(data, symbolContent, mappedWithName, location, content) {
+    let functionName;
+    if (symbolContent.length === 1 && symbolContent[0].name === "STR_CONST" /* RawRType.StringConst */) {
+        const stringBase = (0, values_1.normalizeString)(data, symbolContent[0].content);
+        functionName = {
+            type: "RSymbol" /* RType.Symbol */,
+            namespace: undefined,
+            lexeme: stringBase.lexeme,
+            info: stringBase.info,
+            location: stringBase.location,
+            content: stringBase.content.str
+        };
+    }
+    else {
+        functionName = (0, values_1.tryNormalizeSymbol)(data, symbolContent);
+    }
+    (0, assert_1.guard)(functionName !== undefined, 'expected function name to be a symbol, yet received none');
+    (0, assert_1.guard)(functionName.type === "RSymbol" /* RType.Symbol */, () => `expected function name to be a symbol, yet received ${JSON.stringify(functionName)}`);
+    const parsedArguments = parseArguments(mappedWithName, data);
+    return {
+        type: "RFunctionCall" /* RType.FunctionCall */,
+        flavor: 'named',
+        location,
+        lexeme: content,
+        functionName,
+        arguments: parsedArguments,
+        info: {
+            fullRange: data.currentRange,
+            additionalTokens: [],
+            fullLexeme: data.currentLexeme
+        }
+    };
+}
+//# sourceMappingURL=call.js.map

package/r-bridge/lang-4.x/ast/parser/xml/v1/internal/functions/definition.js

@@ -0,0 +1,60 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.tryNormalizeFunctionDefinition = void 0;
+const normalize_1 = require("../../normalize");
+const hooks_1 = require("../../hooks");
+const meta_1 = require("../../../common/meta");
+const assert_1 = require("../../../../../../../../util/assert");
+const arrays_1 = require("../../../../../../../../util/arrays");
+const structure_1 = require("../structure");
+const parameter_1 = require("./parameter");
+const log_1 = require("../../../../../../../../util/log");
+/**
+ * Tries to parse the given data as a function definition.
+ *
+ * @param data - The data used by the parser (see {@link ParserData})
+ * @param mappedWithName - The json object to extract the meta-information from
+ *
+ * @returns The parsed {@link RFunctionDefinition} or `undefined` if the given construct is not a function definition
+ */
+function tryNormalizeFunctionDefinition(data, mappedWithName) {
+    const fnBase = mappedWithName[0];
+    if (fnBase.name !== "FUNCTION" /* RawRType.Function */ && fnBase.name !== "\\\\" /* RawRType.Lambda */) {
+        normalize_1.parseLog.trace(`expected function definition to be identified by keyword, yet received ${fnBase.name}`);
+        return (0, hooks_1.executeUnknownHook)(data.hooks.functions.onFunctionDefinition.unknown, data, mappedWithName);
+    }
+    normalize_1.parseLog.trace('trying to parse function definition');
+    mappedWithName = (0, hooks_1.executeHook)(data.hooks.functions.onFunctionDefinition.before, data, mappedWithName);
+    const { content, location } = (0, meta_1.retrieveMetaStructure)(data.config, fnBase.content);
+    const openParen = mappedWithName[1];
+    (0, assert_1.guard)(openParen.name === "(" /* RawRType.ParenLeft */, () => `expected opening parenthesis, yet received ${openParen.name}`);
+    const closingParenIndex = mappedWithName.findIndex(x => x.name === ")" /* RawRType.ParenRight */);
+    (0, assert_1.guard)(closingParenIndex !== -1, () => `expected closing parenthesis, yet received ${JSON.stringify(mappedWithName)}`);
+    const splitParameters = (0, arrays_1.splitArrayOn)(mappedWithName.slice(2, closingParenIndex), x => x.name === "," /* RawRType.Comma */);
+    normalize_1.parseLog.trace(`function definition has ${splitParameters.length} parameters (by comma split)`);
+    const parameters = splitParameters.map(x => (0, parameter_1.tryNormalizeParameter)(data, x));
+    if (parameters.some(p => p === undefined)) {
+        log_1.log.error(`function had unexpected unknown parameters: ${JSON.stringify(parameters.filter(assert_1.isNotUndefined))}, aborting.`);
+        return (0, hooks_1.executeUnknownHook)(data.hooks.functions.onFunctionDefinition.unknown, data, mappedWithName);
+    }
+    normalize_1.parseLog.trace(`function definition retained ${parameters.length} parameters after parsing, moving to body.`);
+    const bodyStructure = mappedWithName.slice(closingParenIndex + 1);
+    (0, assert_1.guard)(bodyStructure.length === 1, () => `expected function body to be unique, yet received ${bodyStructure.length}`);
+    const body = (0, structure_1.normalizeBasedOnType)(data, bodyStructure);
+    (0, assert_1.guard)(body.length === 1 && body[0].type !== "RDelimiter" /* RType.Delimiter */, () => `expected function body to yield one normalized expression, but ${body.length}`);
+    const result = {
+        type: "RFunctionDefinition" /* RType.FunctionDefinition */,
+        location,
+        lexeme: content,
+        parameters: parameters,
+        body: (0, meta_1.ensureExpressionList)(body[0]),
+        info: {
+            fullRange: data.currentRange,
+            additionalTokens: [],
+            fullLexeme: data.currentLexeme
+        }
+    };
+    return (0, hooks_1.executeHook)(data.hooks.functions.onFunctionDefinition.after, data, result);
+}
+exports.tryNormalizeFunctionDefinition = tryNormalizeFunctionDefinition;
+//# sourceMappingURL=definition.js.map

package/r-bridge/lang-4.x/ast/parser/xml/v1/internal/functions/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("./call"), exports);
+__exportStar(require("./definition"), exports);
+/* will not expose argument as we know when to expect arguments and only call them during parsing call/definition */
+//# sourceMappingURL=index.js.map

package/r-bridge/lang-4.x/ast/parser/xml/v1/internal/functions/parameter.js

@@ -0,0 +1,64 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.tryNormalizeParameter = void 0;
+const normalize_1 = require("../../normalize");
+const meta_1 = require("../../../common/meta");
+const hooks_1 = require("../../hooks");
+const log_1 = require("../../../../../../../../util/log");
+const assert_1 = require("../../../../../../../../util/assert");
+const structure_1 = require("../structure");
+/**
+ * Either parses `[SYMBOL_FORMALS]` or `[SYMBOL_FORMALS, EQ_FORMALS, expr]` as a parameter of a function definition in R.
+ * Probably directly called by the function definition parser as otherwise, we do not expect to find parameters.
+ *
+ * @param data - The data used by the parser (see {@link ParserData})
+ * @param objs - Either `[SYMBOL_FORMALS]` or `[SYMBOL_FORMALS, EQ_FORMALS, expr]`
+ *
+ * @returns The parsed parameter or `undefined` if the given object is not a parameter.
+ */
+function tryNormalizeParameter(data, objs) {
+    normalize_1.parseLog.debug('[parameter]');
+    objs = (0, hooks_1.executeHook)(data.hooks.functions.onParameter.before, data, objs);
+    if (objs.length !== 1 && objs.length !== 3) {
+        log_1.log.warn(`Either [SYMBOL_FORMALS] or [SYMBOL_FORMALS, EQ_FORMALS, expr], but got: ${JSON.stringify(objs)}`);
+        return (0, hooks_1.executeUnknownHook)(data.hooks.functions.onParameter.unknown, data, objs);
+    }
+    const symbol = objs[0];
+    if (symbol.name !== "SYMBOL_FORMALS" /* RawRType.SymbolFormals */) {
+        log_1.log.warn(`expected symbol for parameter, yet received ${JSON.stringify(objs)}`);
+        return (0, hooks_1.executeUnknownHook)(data.hooks.functions.onParameter.unknown, data, objs);
+    }
+    const defaultValue = objs.length === 3 ? parseWithDefaultValue(data, objs) : undefined;
+    const { location, content } = (0, meta_1.retrieveMetaStructure)(data.config, symbol.content);
+    const result = {
+        type: "RParameter" /* RType.Parameter */,
+        location,
+        special: content === '...',
+        lexeme: content,
+        name: {
+            type: "RSymbol" /* RType.Symbol */,
+            location, content,
+            namespace: undefined,
+            lexeme: content,
+            info: {
+                fullRange: location,
+                additionalTokens: [],
+                fullLexeme: content
+            }
+        },
+        defaultValue: defaultValue?.type === "RDelimiter" /* RType.Delimiter */ ? undefined : defaultValue,
+        info: {
+            fullRange: location,
+            fullLexeme: content,
+            additionalTokens: defaultValue?.type === "RDelimiter" /* RType.Delimiter */ ? [defaultValue] : []
+        }
+    };
+    return (0, hooks_1.executeHook)(data.hooks.functions.onParameter.after, data, result);
+}
+exports.tryNormalizeParameter = tryNormalizeParameter;
+function parseWithDefaultValue(data, objs) {
+    (0, assert_1.guard)(objs[1].name === "EQ_FORMALS" /* RawRType.EqualFormals */, () => `[arg-default] second element of parameter must be ${"EQ_FORMALS" /* RawRType.EqualFormals */}, but: ${JSON.stringify(objs)}`);
+    (0, assert_1.guard)(objs[2].name === "expr" /* RawRType.Expression */, () => `[arg-default] third element of parameter must be an Expression but: ${JSON.stringify(objs)}`);
+    return (0, structure_1.tryNormalizeSingleNode)(data, objs[2]);
+}
+//# sourceMappingURL=parameter.js.map

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

@@ -0,0 +1,27 @@
+"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("./loops"), exports);
+__exportStar(require("./other"), exports);
+__exportStar(require("./values"), exports);
+__exportStar(require("./control"), exports);
+__exportStar(require("./functions"), exports);
+__exportStar(require("./operators"), exports);
+__exportStar(require("./structure"), exports);
+__exportStar(require("./expression"), exports);
+__exportStar(require("../../common/meta"), exports);
+__exportStar(require("../../common/xml-to-json"), exports);
+//# sourceMappingURL=index.js.map

package/r-bridge/lang-4.x/ast/parser/xml/v1/internal/loops/break.js

@@ -0,0 +1,24 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.normalizeBreak = void 0;
+const normalize_1 = require("../../normalize");
+const hooks_1 = require("../../hooks");
+const meta_1 = require("../../../common/meta");
+function normalizeBreak(data, obj) {
+    normalize_1.parseLog.debug(`[break] try: ${JSON.stringify(obj)}`);
+    obj = (0, hooks_1.executeHook)(data.hooks.loops.onBreak.before, data, obj);
+    const { location, content } = (0, meta_1.retrieveMetaStructure)(data.config, obj);
+    const result = {
+        type: "RBreak" /* RType.Break */,
+        location,
+        lexeme: content,
+        info: {
+            fullRange: location,
+            additionalTokens: [],
+            fullLexeme: content
+        }
+    };
+    return (0, hooks_1.executeHook)(data.hooks.loops.onBreak.after, data, result);
+}
+exports.normalizeBreak = normalizeBreak;
+//# sourceMappingURL=break.js.map

package/r-bridge/lang-4.x/ast/parser/xml/v1/internal/loops/for.js

@@ -0,0 +1,72 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.tryNormalizeFor = void 0;
+const input_format_1 = require("../../../common/input-format");
+const meta_1 = require("../../../common/meta");
+const normalize_1 = require("../../normalize");
+const assert_1 = require("../../../../../../../../util/assert");
+const values_1 = require("../values");
+const structure_1 = require("../structure");
+const hooks_1 = require("../../hooks");
+const other_1 = require("../other");
+function tryNormalizeFor(data, forToken, head, body) {
+    // funny, for does not use top-level parenthesis
+    if (forToken.name !== "FOR" /* RawRType.For */) {
+        normalize_1.parseLog.debug('encountered non-for token for supposed for-loop structure');
+        return (0, hooks_1.executeUnknownHook)(data.hooks.loops.onForLoop.unknown, data, { forToken, condition: head, body });
+    }
+    else if (head.name !== "forcond" /* RawRType.ForCondition */) {
+        throw new input_format_1.XmlParseError(`expected condition for for-loop but found ${JSON.stringify(head)}`);
+    }
+    else if (body.name !== "expr" /* RawRType.Expression */ && body.name !== "expr_or_assign_or_help" /* RawRType.ExprOfAssignOrHelp */) {
+        throw new input_format_1.XmlParseError(`expected expr body for for-loop but found ${JSON.stringify(body)}`);
+    }
+    normalize_1.parseLog.debug('trying to parse for-loop');
+    const newParseData = { ...data, data, currentRange: undefined, currentLexeme: undefined };
+    ({ forToken, condition: head, body } = (0, hooks_1.executeHook)(data.hooks.loops.onForLoop.before, data, { forToken, condition: head, body }));
+    const { variable: parsedVariable, vector: parsedVector, comments } = normalizeForHead(newParseData, head.content);
+    const parseBody = (0, structure_1.tryNormalizeSingleNode)(newParseData, body);
+    if (parsedVariable === undefined ||
+        parsedVector === undefined ||
+        parseBody.type === "RDelimiter" /* RType.Delimiter */) {
+        throw new input_format_1.XmlParseError(`unexpected under-sided for-loop, received ${JSON.stringify([
+            parsedVariable,
+            parsedVariable,
+            parseBody,
+        ])}`);
+    }
+    const { location, content } = (0, meta_1.retrieveMetaStructure)(data.config, forToken.content);
+    const result = {
+        type: "RForLoop" /* RType.ForLoop */,
+        variable: parsedVariable,
+        vector: parsedVector,
+        body: (0, meta_1.ensureExpressionList)(parseBody),
+        lexeme: content,
+        info: {
+            fullRange: data.currentRange,
+            additionalTokens: comments,
+            fullLexeme: data.currentLexeme,
+        },
+        location
+    };
+    return (0, hooks_1.executeHook)(data.hooks.loops.onForLoop.after, data, result);
+}
+exports.tryNormalizeFor = tryNormalizeFor;
+function normalizeForHead(data, forCondition) {
+    // must have a child which is `in`, a variable on the left, and a vector on the right
+    const children = (0, input_format_1.getKeyGuarded)(forCondition, data.config.children).map(content => ({
+        name: (0, meta_1.getTokenType)(data.config.tokenMap, content),
+        content
+    }));
+    const { comments, others } = (0, structure_1.splitComments)(children);
+    const inPosition = others.findIndex(elem => elem.name === "IN" /* RawRType.ForIn */);
+    (0, assert_1.guard)(inPosition > 0 && inPosition < others.length - 1, () => `for loop searched in and found at ${inPosition}, but this is not in legal bounds for ${JSON.stringify(children)}`);
+    const variable = (0, values_1.tryNormalizeSymbol)(data, [others[inPosition - 1]]);
+    (0, assert_1.guard)(variable !== undefined, () => `for loop variable should have been parsed to a symbol but was ${JSON.stringify(variable)}`);
+    (0, assert_1.guard)(variable.type === "RSymbol" /* RType.Symbol */, () => `for loop variable should have been parsed to a symbol but was ${JSON.stringify(variable)}`);
+    const vector = (0, structure_1.normalizeBasedOnType)(data, [others[inPosition + 1]]);
+    (0, assert_1.guard)(vector.length === 1 && vector[0].type !== "RDelimiter" /* RType.Delimiter */, () => `for loop vector should have been parsed to a single element but was ${JSON.stringify(vector)}`);
+    const parsedComments = comments.map(c => (0, other_1.normalizeComment)(data, c.content));
+    return { variable, vector: vector[0], comments: parsedComments };
+}
+//# sourceMappingURL=for.js.map

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

@@ -0,0 +1,22 @@
+"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("./for"), exports);
+__exportStar(require("./while"), exports);
+__exportStar(require("./repeat"), exports);
+__exportStar(require("./break"), exports);
+__exportStar(require("./next"), exports);
+//# sourceMappingURL=index.js.map

package/r-bridge/lang-4.x/ast/parser/xml/v1/internal/loops/next.js

@@ -0,0 +1,24 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.normalizeNext = void 0;
+const normalize_1 = require("../../normalize");
+const hooks_1 = require("../../hooks");
+const meta_1 = require("../../../common/meta");
+function normalizeNext(data, obj) {
+    normalize_1.parseLog.debug(`[next] try: ${JSON.stringify(obj)}`);
+    obj = (0, hooks_1.executeHook)(data.hooks.loops.onNext.before, data, obj);
+    const { location, content } = (0, meta_1.retrieveMetaStructure)(data.config, obj);
+    const result = {
+        type: "RNext" /* RType.Next */,
+        location,
+        lexeme: content,
+        info: {
+            fullRange: data.currentRange,
+            additionalTokens: [],
+            fullLexeme: data.currentLexeme
+        }
+    };
+    return (0, hooks_1.executeHook)(data.hooks.loops.onNext.after, data, result);
+}
+exports.normalizeNext = normalizeNext;
+//# sourceMappingURL=next.js.map

package/r-bridge/lang-4.x/ast/parser/xml/v1/internal/loops/repeat.js

@@ -0,0 +1,42 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.tryNormalizeRepeat = void 0;
+const meta_1 = require("../../../common/meta");
+const normalize_1 = require("../../normalize");
+const structure_1 = require("../structure");
+const assert_1 = require("../../../../../../../../util/assert");
+const hooks_1 = require("../../hooks");
+/**
+ * Try to parse the construct as a {@link RRepeatLoop}.
+ *
+ * @param data - The data used by the parser (see {@link ParserData})
+ * @param repeatToken - Token which represents the `repeat` keyword
+ * @param body - The `body` of the repeat-loop
+ *
+ * @returns The parsed {@link RRepeatLoop} or `undefined` if the given construct is not a repeat-loop
+ */
+function tryNormalizeRepeat(data, repeatToken, body) {
+    if (repeatToken.name !== "REPEAT" /* RawRType.Repeat */) {
+        normalize_1.parseLog.debug('encountered non-repeat token for supposed repeat-loop structure');
+        return (0, hooks_1.executeUnknownHook)(data.hooks.loops.onRepeatLoop.unknown, data, { repeatToken, body });
+    }
+    normalize_1.parseLog.debug('trying to parse repeat-loop');
+    ({ repeatToken, body } = (0, hooks_1.executeHook)(data.hooks.loops.onRepeatLoop.before, data, { repeatToken, body }));
+    const parseBody = (0, structure_1.tryNormalizeSingleNode)(data, body);
+    (0, assert_1.guard)(parseBody.type !== "RDelimiter" /* RType.Delimiter */, () => `no body for repeat-loop ${JSON.stringify(repeatToken)} (${JSON.stringify(body)})`);
+    const { location, content } = (0, meta_1.retrieveMetaStructure)(data.config, repeatToken.content);
+    const result = {
+        type: "RRepeatLoop" /* RType.RepeatLoop */,
+        location,
+        lexeme: content,
+        body: (0, meta_1.ensureExpressionList)(parseBody),
+        info: {
+            fullRange: data.currentRange,
+            additionalTokens: [],
+            fullLexeme: data.currentLexeme
+        }
+    };
+    return (0, hooks_1.executeHook)(data.hooks.loops.onRepeatLoop.after, data, result);
+}
+exports.tryNormalizeRepeat = tryNormalizeRepeat;
+//# sourceMappingURL=repeat.js.map

package/r-bridge/lang-4.x/ast/parser/xml/v1/internal/loops/while.js

@@ -0,0 +1,45 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.tryNormalizeWhile = void 0;
+const input_format_1 = require("../../../common/input-format");
+const meta_1 = require("../../../common/meta");
+const normalize_1 = require("../../normalize");
+const structure_1 = require("../structure");
+const hooks_1 = require("../../hooks");
+function tryNormalizeWhile(data, whileToken, leftParen, condition, rightParen, body) {
+    if (whileToken.name !== "WHILE" /* RawRType.While */) {
+        normalize_1.parseLog.debug('encountered non-while token for supposed while-loop structure');
+        return (0, hooks_1.executeUnknownHook)(data.hooks.loops.onWhileLoop.unknown, data, { whileToken, leftParen, condition, rightParen, body });
+    }
+    else if (leftParen.name !== "(" /* RawRType.ParenLeft */) {
+        throw new input_format_1.XmlParseError(`expected left-parenthesis for while but found ${JSON.stringify(leftParen)}`);
+    }
+    else if (rightParen.name !== ")" /* RawRType.ParenRight */) {
+        throw new input_format_1.XmlParseError(`expected right-parenthesis for while but found ${JSON.stringify(rightParen)}`);
+    }
+    normalize_1.parseLog.debug('trying to parse while-loop');
+    const parsedCondition = (0, structure_1.tryNormalizeSingleNode)(data, condition);
+    const parseBody = (0, structure_1.tryNormalizeSingleNode)(data, body);
+    if (parsedCondition.type === "RDelimiter" /* RType.Delimiter */ || parseBody.type === "RDelimiter" /* RType.Delimiter */) {
+        throw new input_format_1.XmlParseError(`unexpected under-sided while-loop, received ${JSON.stringify([
+            parsedCondition,
+            parseBody,
+        ])} for ${JSON.stringify([whileToken, condition, body])}`);
+    }
+    const { location, content } = (0, meta_1.retrieveMetaStructure)(data.config, whileToken.content);
+    const result = {
+        type: "RWhileLoop" /* RType.WhileLoop */,
+        condition: parsedCondition,
+        body: (0, meta_1.ensureExpressionList)(parseBody),
+        lexeme: content,
+        location,
+        info: {
+            fullRange: data.currentRange,
+            additionalTokens: [],
+            fullLexeme: data.currentLexeme
+        }
+    };
+    return (0, hooks_1.executeHook)(data.hooks.loops.onWhileLoop.after, data, result);
+}
+exports.tryNormalizeWhile = tryNormalizeWhile;
+//# sourceMappingURL=while.js.map