@eagleoutice/flowr 1.5.1 → 2.0.0

package/r-bridge/lang-4.x/ast/parser/xml/internal/functions/{argument.js → normalize-argument.js}

@@ -1,35 +1,32 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.tryToNormalizeArgument = void 0;
-const meta_1 = require("../meta");
-const hooks_1 = require("../../hooks");
-const log_1 = require("../../../../../../../util/log");
-const assert_1 = require("../../../../../../../util/assert");
-const structure_1 = require("../structure");
 const parser_1 = require("../../../json/parser");
+const normalize_meta_1 = require("../../normalize-meta");
+const assert_1 = require("../../../../../../../util/assert");
+const normalize_single_node_1 = require("../structure/normalize-single-node");
 /**
  * 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 data - The data used by the parser (see {@link ParserData})
+ * @param data - The data used by the parser (see {@link NormalizerData})
  * @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(data, objs) {
     parser_1.parseLog.debug('[argument]');
-    objs = (0, hooks_1.executeHook)(data.hooks.functions.onArgument.before, data, 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 => o.name).join(', ')}`);
-        return (0, hooks_1.executeUnknownHook)(data.hooks.functions.onArgument.unknown, data, objs);
+        parser_1.parseLog.warn(`Either [expr|value], [SYMBOL_SUB, EQ_SUB], or [SYMBOL_SUB, EQ_SUB, expr], but got: ${objs.map(o => o.name).join(', ')}`);
+        return undefined;
     }
     const symbolOrExpr = objs[0];
-    const { location, content } = (0, meta_1.retrieveMetaStructure)(symbolOrExpr.content);
+    const { location, content } = (0, normalize_meta_1.retrieveMetaStructure)(symbolOrExpr.content);
     let parsedValue;
     let name;
     if (symbolOrExpr.name === "expr" /* RawRType.Expression */) {
         name = undefined;
-        parsedValue = (0, structure_1.tryNormalizeSingleNode)(data, symbolOrExpr);
+        parsedValue = (0, normalize_single_node_1.normalizeSingleNode)(data, symbolOrExpr);
     }
     else if (symbolOrExpr.name === "SYMBOL_SUB" /* RawRType.SymbolSub */ || symbolOrExpr.name === "STR_CONST" /* RawRType.StringConst */) {
         name = {
@@ -47,11 +44,11 @@ function tryToNormalizeArgument(data, objs) {
         parsedValue = parseWithValue(data, objs);
     }
     else {
-        log_1.log.warn(`expected symbol or expr for argument, yet received ${objs.map(o => o.name).join(',')}`);
-        return (0, hooks_1.executeUnknownHook)(data.hooks.functions.onArgument.unknown, data, objs);
+        parser_1.parseLog.warn(`expected symbol or expr for argument, yet received ${objs.map(o => o.name).join(',')}`);
+        return undefined;
     }
     (0, assert_1.guard)(parsedValue !== undefined && parsedValue?.type !== "RDelimiter" /* RType.Delimiter */, () => `[argument] parsed value must not be undefined, yet: ${JSON.stringify(objs)}`);
-    const result = {
+    return {
         type: "RArgument" /* RType.Argument */,
         location,
         lexeme: content,
@@ -63,12 +60,11 @@ function tryToNormalizeArgument(data, objs) {
             additionalTokens: []
         }
     };
-    return (0, hooks_1.executeHook)(data.hooks.functions.onArgument.after, data, result);
 }
 exports.tryToNormalizeArgument = tryToNormalizeArgument;
 function parseWithValue(data, objs) {
     (0, assert_1.guard)(objs[1].name === "EQ_SUB" /* RawRType.EqualSub */, () => `[arg-default] second element of parameter must be ${"EQ_FORMALS" /* RawRType.EqualFormals */}, but: ${JSON.stringify(objs)}`);
     (0, assert_1.guard)(objs.length === 2 || objs[2].name === "expr" /* RawRType.Expression */, () => `[arg-default] third element of parameter must be an Expression or undefined (for 'x=') but: ${JSON.stringify(objs)}`);
-    return objs[2] ? (0, structure_1.tryNormalizeSingleNode)(data, objs[2]) : null;
+    return objs[2] ? (0, normalize_single_node_1.normalizeSingleNode)(data, objs[2]) : null;
 }
-//# sourceMappingURL=argument.js.map
+//# sourceMappingURL=normalize-argument.js.map

package/r-bridge/lang-4.x/ast/parser/xml/internal/functions/{call.d.ts → normalize-call.d.ts}

@@ -1,13 +1,15 @@
+import type { NormalizerData } from '../../normalizer-data';
 import type { NamedXmlBasedJson } from '../../input-format';
-import type { ParserData } from '../../data';
-import type { RFunctionCall, RNext, RBreak } from '../../../../model';
+import type { RFunctionCall } from '../../../../model/nodes/r-function-call';
+import type { RNext } from '../../../../model/nodes/r-next';
+import type { RBreak } from '../../../../model/nodes/r-break';
 /**
  * Tries to parse the given data as a function call.
  *
- * @param data           - The data used by the parser (see {@link ParserData})
+ * @param data           - The data used by the parser (see {@link NormalizerData})
  * @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.
  */
-export declare function tryNormalizeFunctionCall(data: ParserData, mappedWithName: NamedXmlBasedJson[]): RFunctionCall | RNext | RBreak | undefined;
+export declare function tryNormalizeFunctionCall(data: NormalizerData, mappedWithName: NamedXmlBasedJson[]): RFunctionCall | RNext | RBreak | undefined;

package/r-bridge/lang-4.x/ast/parser/xml/internal/functions/{call.js → normalize-call.js}

@@ -2,18 +2,19 @@
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.tryNormalizeFunctionCall = void 0;
 const input_format_1 = require("../../input-format");
-const assert_1 = require("../../../../../../../util/assert");
-const meta_1 = require("../meta");
-const arrays_1 = require("../../../../../../../util/arrays");
-const values_1 = require("../values");
-const hooks_1 = require("../../hooks");
-const argument_1 = require("./argument");
-const expression_1 = require("../expression");
 const parser_1 = require("../../../json/parser");
+const normalize_meta_1 = require("../../normalize-meta");
+const arrays_1 = require("../../../../../../../util/arrays");
+const assert_1 = require("../../../../../../../util/assert");
+const normalize_argument_1 = require("./normalize-argument");
+const r_function_call_1 = require("../../../../model/nodes/r-function-call");
+const normalize_expression_1 = require("../expression/normalize-expression");
+const normalize_string_1 = require("../values/normalize-string");
+const normalize_symbol_1 = require("../values/normalize-symbol");
 /**
  * Tries to parse the given data as a function call.
  *
- * @param data           - The data used by the parser (see {@link ParserData})
+ * @param data           - The data used by the parser (see {@link NormalizerData})
  * @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
@@ -23,34 +24,28 @@ function tryNormalizeFunctionCall(data, mappedWithName) {
     const fnBase = mappedWithName[0];
     if (fnBase.name !== "expr" /* RawRType.Expression */ && fnBase.name !== "expr_or_assign_or_help" /* RawRType.ExprOfAssignOrHelp */) {
         parser_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);
+        return undefined;
     }
     if (mappedWithName.length < 3 || mappedWithName[1].name !== "(" /* RawRType.ParenLeft */ || mappedWithName[mappedWithName.length - 1].name !== ")" /* RawRType.ParenRight */) {
         parser_1.parseLog.trace('expected function call to have parenthesis for a call, but was not');
         return undefined;
     }
     parser_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)(fnBase.content);
-    const symbolContent = (0, input_format_1.getKeysGuarded)(unwrappedObj, input_format_1.childrenKey);
-    let result;
-    const namedSymbolContent = (0, meta_1.getWithTokenType)(symbolContent);
+    const { unwrappedObj, content, location } = (0, normalize_meta_1.retrieveMetaStructure)(fnBase.content);
+    const symbolContent = (0, input_format_1.getKeyGuarded)(unwrappedObj, input_format_1.childrenKey);
+    const namedSymbolContent = (0, normalize_meta_1.getWithTokenType)(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);
+        return parseNamedFunctionCall(data, namedSymbolContent, mappedWithName, location, content);
     }
     else if (namedSymbolContent.findIndex(x => x.name === "SYMBOL_FUNCTION_CALL" /* RawRType.SymbolFunctionCall */) < 0) {
         parser_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;
+        return mayResult;
     }
     else {
-        result = parseNamedFunctionCall(data, namedSymbolContent, mappedWithName, location, content);
+        return 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) {
@@ -59,7 +54,7 @@ function parseArguments(mappedWithName, data) {
     const splitArgumentsOnComma = (0, arrays_1.splitArrayOn)(argContainer.slice(1, argContainer.length - 1), x => x.name === "," /* RawRType.Comma */);
     return splitArgumentsOnComma.map(x => {
         parser_1.parseLog.trace('trying to parse argument');
-        return (0, argument_1.tryToNormalizeArgument)(data, x);
+        return (0, normalize_argument_1.tryToNormalizeArgument)(data, x);
     });
 }
 function tryParseUnnamedFunctionCall(data, mappedWithName, location, content) {
@@ -70,7 +65,7 @@ function tryParseUnnamedFunctionCall(data, mappedWithName, location, content) {
     }
     parser_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 calledFunction = (0, normalize_expression_1.normalizeExpression)(data, mappedWithName[0].content);
     const parsedArguments = parseArguments(mappedWithName, data);
     if (parsedArguments.length === 0) {
         // sadly, next() and break() work
@@ -105,7 +100,7 @@ function tryParseUnnamedFunctionCall(data, mappedWithName, location, content) {
         location,
         lexeme: content,
         calledFunction: calledFunction,
-        arguments: parsedArguments,
+        arguments: parsedArguments.map(x => x ?? r_function_call_1.EmptyArgument),
         info: {
             fullRange: data.currentRange,
             additionalTokens: [],
@@ -116,7 +111,7 @@ function tryParseUnnamedFunctionCall(data, mappedWithName, location, content) {
 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);
+        const stringBase = (0, normalize_string_1.normalizeString)(data, symbolContent[0].content);
         functionName = {
             type: "RSymbol" /* RType.Symbol */,
             namespace: undefined,
@@ -127,10 +122,10 @@ function parseNamedFunctionCall(data, symbolContent, mappedWithName, location, c
         };
     }
     else {
-        functionName = (0, values_1.tryNormalizeSymbol)(data, symbolContent);
+        functionName = (0, normalize_symbol_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)}`);
+    (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 */,
@@ -138,7 +133,7 @@ function parseNamedFunctionCall(data, symbolContent, mappedWithName, location, c
         location,
         lexeme: content,
         functionName,
-        arguments: parsedArguments,
+        arguments: parsedArguments.map(x => x ?? r_function_call_1.EmptyArgument),
         info: {
             fullRange: data.currentRange,
             additionalTokens: [],
@@ -146,4 +141,4 @@ function parseNamedFunctionCall(data, symbolContent, mappedWithName, location, c
         }
     };
 }
-//# sourceMappingURL=call.js.map
+//# sourceMappingURL=normalize-call.js.map

package/r-bridge/lang-4.x/ast/parser/xml/internal/functions/normalize-definition.d.ts

@@ -0,0 +1,12 @@
+import type { NormalizerData } from '../../normalizer-data';
+import type { NamedXmlBasedJson } from '../../input-format';
+import type { RFunctionDefinition } from '../../../../model/nodes/r-function-definition';
+/**
+ * Tries to parse the given data as a function definition.
+ *
+ * @param data - The data used by the parser (see {@link NormalizerData})
+ * @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
+ */
+export declare function tryNormalizeFunctionDefinition(data: NormalizerData, mappedWithName: readonly NamedXmlBasedJson[]): RFunctionDefinition | undefined;

package/r-bridge/lang-4.x/ast/parser/xml/internal/functions/{definition.js → normalize-definition.js}

@@ -1,18 +1,16 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.tryNormalizeFunctionDefinition = void 0;
-const hooks_1 = require("../../hooks");
-const meta_1 = require("../meta");
+const parser_1 = require("../../../json/parser");
+const normalize_meta_1 = require("../../normalize-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");
-const parser_1 = require("../../../json/parser");
+const normalize_parameter_1 = require("./normalize-parameter");
+const normalize_expressions_1 = require("../structure/normalize-expressions");
 /**
  * Tries to parse the given data as a function definition.
  *
- * @param data - The data used by the parser (see {@link ParserData})
+ * @param data - The data used by the parser (see {@link NormalizerData})
  * @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
@@ -21,40 +19,37 @@ function tryNormalizeFunctionDefinition(data, mappedWithName) {
     const fnBase = mappedWithName[0];
     if (fnBase.name !== "FUNCTION" /* RawRType.Function */ && fnBase.name !== "\\\\" /* RawRType.Lambda */) {
         parser_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);
+        return undefined;
     }
-    parser_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)(fnBase.content);
+    const { content, location } = (0, normalize_meta_1.retrieveMetaStructure)(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 */);
     parser_1.parseLog.trace(`function definition has ${splitParameters.length} parameters (by comma split)`);
-    const parameters = splitParameters.map(x => (0, parameter_1.tryNormalizeParameter)(data, x));
+    const parameters = splitParameters.map(x => (0, normalize_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);
+        parser_1.parseLog.error(`function had unexpected unknown parameters: ${JSON.stringify(parameters.filter(assert_1.isNotUndefined))}, aborting.`);
+        return undefined;
     }
     parser_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);
+    const body = (0, normalize_expressions_1.normalizeExpressions)(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 = {
+    return {
         type: "RFunctionDefinition" /* RType.FunctionDefinition */,
         location,
         lexeme: content,
         parameters: parameters,
-        body: (0, meta_1.ensureExpressionList)(body[0]),
+        body: (0, normalize_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
+//# sourceMappingURL=normalize-definition.js.map

package/r-bridge/lang-4.x/ast/parser/xml/internal/functions/{parameter.d.ts → normalize-parameter.d.ts}

@@ -1,13 +1,13 @@
+import type { NormalizerData } from '../../normalizer-data';
 import type { NamedXmlBasedJson } from '../../input-format';
-import type { RParameter } from '../../../../model';
-import type { ParserData } from '../../data';
+import type { RParameter } from '../../../../model/nodes/r-parameter';
 /**
  * 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 data - The data used by the parser (see {@link NormalizerData})
  * @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.
  */
-export declare function tryNormalizeParameter(data: ParserData, objs: NamedXmlBasedJson[]): RParameter | undefined;
+export declare function tryNormalizeParameter(data: NormalizerData, objs: readonly NamedXmlBasedJson[]): RParameter | undefined;

package/r-bridge/lang-4.x/ast/parser/xml/internal/functions/{parameter.js → normalize-parameter.js}

@@ -1,36 +1,33 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.tryNormalizeParameter = void 0;
-const meta_1 = require("../meta");
-const hooks_1 = require("../../hooks");
-const log_1 = require("../../../../../../../util/log");
-const assert_1 = require("../../../../../../../util/assert");
-const structure_1 = require("../structure");
 const parser_1 = require("../../../json/parser");
+const normalize_meta_1 = require("../../normalize-meta");
+const assert_1 = require("../../../../../../../util/assert");
+const normalize_single_node_1 = require("../structure/normalize-single-node");
 /**
  * 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 data - The data used by the parser (see {@link NormalizerData})
  * @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) {
     parser_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);
+        parser_1.parseLog.warn(`Either [SYMBOL_FORMALS] or [SYMBOL_FORMALS, EQ_FORMALS, expr], but got: ${JSON.stringify(objs)}`);
+        return undefined;
     }
     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);
+        parser_1.parseLog.warn(`expected symbol for parameter, yet received ${JSON.stringify(objs)}`);
+        return undefined;
     }
     const defaultValue = objs.length === 3 ? parseWithDefaultValue(data, objs) : undefined;
-    const { location, content } = (0, meta_1.retrieveMetaStructure)(symbol.content);
-    const result = {
+    const { location, content } = (0, normalize_meta_1.retrieveMetaStructure)(symbol.content);
+    return {
         type: "RParameter" /* RType.Parameter */,
         location,
         special: content === '...',
@@ -53,12 +50,11 @@ function tryNormalizeParameter(data, objs) {
             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]);
+    return (0, normalize_single_node_1.normalizeSingleNode)(data, objs[2]);
 }
-//# sourceMappingURL=parameter.js.map
+//# sourceMappingURL=normalize-parameter.js.map

package/r-bridge/lang-4.x/ast/parser/xml/internal/loops/normalize-break.d.ts

@@ -0,0 +1,4 @@
+import type { NormalizerData } from '../../normalizer-data';
+import type { XmlBasedJson } from '../../input-format';
+import type { RBreak } from '../../../../model/nodes/r-break';
+export declare function normalizeBreak(data: NormalizerData, obj: XmlBasedJson): RBreak;

package/r-bridge/lang-4.x/ast/parser/xml/internal/loops/{break.js → normalize-break.js}

@@ -1,14 +1,13 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.normalizeBreak = void 0;
-const hooks_1 = require("../../hooks");
-const meta_1 = require("../meta");
 const parser_1 = require("../../../json/parser");
+const log_1 = require("../../../../../../../util/log");
+const normalize_meta_1 = require("../../normalize-meta");
 function normalizeBreak(data, obj) {
-    parser_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)(obj);
-    const result = {
+    (0, log_1.expensiveTrace)(parser_1.parseLog, () => `[break] ${JSON.stringify(obj)}`);
+    const { location, content } = (0, normalize_meta_1.retrieveMetaStructure)(obj);
+    return {
         type: "RBreak" /* RType.Break */,
         location,
         lexeme: content,
@@ -18,7 +17,6 @@ function normalizeBreak(data, obj) {
             fullLexeme: content
         }
     };
-    return (0, hooks_1.executeHook)(data.hooks.loops.onBreak.after, data, result);
 }
 exports.normalizeBreak = normalizeBreak;
-//# sourceMappingURL=break.js.map
+//# sourceMappingURL=normalize-break.js.map

package/r-bridge/lang-4.x/ast/parser/xml/internal/loops/normalize-for.d.ts

@@ -0,0 +1,4 @@
+import type { NormalizerData } from '../../normalizer-data';
+import type { NamedXmlBasedJson } from '../../input-format';
+import type { RForLoop } from '../../../../model/nodes/r-for-loop';
+export declare function tryNormalizeFor(data: NormalizerData, [forToken, head, body]: [NamedXmlBasedJson, NamedXmlBasedJson, NamedXmlBasedJson]): RForLoop | undefined;

package/r-bridge/lang-4.x/ast/parser/xml/internal/loops/{for.js → normalize-for.js}

@@ -2,18 +2,18 @@
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.tryNormalizeFor = void 0;
 const input_format_1 = require("../../input-format");
-const meta_1 = require("../meta");
-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");
 const parser_1 = require("../../../json/parser");
-function tryNormalizeFor(data, forToken, head, body) {
+const normalize_meta_1 = require("../../normalize-meta");
+const assert_1 = require("../../../../../../../util/assert");
+const normalize_single_node_1 = require("../structure/normalize-single-node");
+const normalize_expressions_1 = require("../structure/normalize-expressions");
+const normalize_symbol_1 = require("../values/normalize-symbol");
+const normalize_comment_1 = require("../other/normalize-comment");
+function tryNormalizeFor(data, [forToken, head, body]) {
     // funny, for does not use top-level parenthesis
     if (forToken.name !== "FOR" /* RawRType.For */) {
         parser_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 });
+        return undefined;
     }
     else if (head.name !== "forcond" /* RawRType.ForCondition */) {
         throw new input_format_1.XmlParseError(`expected condition for for-loop but found ${JSON.stringify(head)}`);
@@ -23,9 +23,8 @@ function tryNormalizeFor(data, forToken, head, body) {
     }
     parser_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);
+    const parseBody = (0, normalize_single_node_1.normalizeSingleNode)(newParseData, body);
     if (parsedVariable === undefined ||
         parsedVector === undefined ||
         parseBody.type === "RDelimiter" /* RType.Delimiter */) {
@@ -35,12 +34,12 @@ function tryNormalizeFor(data, forToken, head, body) {
             parseBody,
         ])}`);
     }
-    const { location, content } = (0, meta_1.retrieveMetaStructure)(forToken.content);
-    const result = {
+    const { location, content } = (0, normalize_meta_1.retrieveMetaStructure)(forToken.content);
+    return {
         type: "RForLoop" /* RType.ForLoop */,
         variable: parsedVariable,
         vector: parsedVector,
-        body: (0, meta_1.ensureExpressionList)(parseBody),
+        body: (0, normalize_meta_1.ensureExpressionList)(parseBody),
         lexeme: content,
         info: {
             fullRange: data.currentRange,
@@ -49,21 +48,20 @@ function tryNormalizeFor(data, forToken, head, body) {
         },
         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.getKeysGuarded)(forCondition, input_format_1.childrenKey).map(content => ({ name: (0, meta_1.getTokenType)(content), content }));
-    const { comments, others } = (0, structure_1.splitComments)(children);
+    const children = (0, input_format_1.getKeyGuarded)(forCondition, input_format_1.childrenKey).map(content => ({ name: (0, normalize_meta_1.getTokenType)(content), content }));
+    const { comments, others } = (0, normalize_expressions_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]]);
+    const variable = (0, normalize_symbol_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]]);
+    const vector = (0, normalize_expressions_1.normalizeExpressions)(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));
+    const parsedComments = comments.map(c => (0, normalize_comment_1.normalizeComment)(data, c.content));
     return { variable, vector: vector[0], comments: parsedComments };
 }
-//# sourceMappingURL=for.js.map
+//# sourceMappingURL=normalize-for.js.map

package/r-bridge/lang-4.x/ast/parser/xml/internal/loops/normalize-next.d.ts

@@ -0,0 +1,4 @@
+import type { NormalizerData } from '../../normalizer-data';
+import type { XmlBasedJson } from '../../input-format';
+import type { RNext } from '../../../../model/nodes/r-next';
+export declare function normalizeNext(data: NormalizerData, obj: XmlBasedJson): RNext;

package/r-bridge/lang-4.x/ast/parser/xml/internal/loops/{next.js → normalize-next.js}

@@ -1,14 +1,13 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.normalizeNext = void 0;
-const hooks_1 = require("../../hooks");
-const meta_1 = require("../meta");
+const log_1 = require("../../../../../../../util/log");
 const parser_1 = require("../../../json/parser");
+const normalize_meta_1 = require("../../normalize-meta");
 function normalizeNext(data, obj) {
-    parser_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)(obj);
-    const result = {
+    (0, log_1.expensiveTrace)(parser_1.parseLog, () => `[next] ${JSON.stringify(obj)}`);
+    const { location, content } = (0, normalize_meta_1.retrieveMetaStructure)(obj);
+    return {
         type: "RNext" /* RType.Next */,
         location,
         lexeme: content,
@@ -18,7 +17,6 @@ function normalizeNext(data, obj) {
             fullLexeme: data.currentLexeme
         }
     };
-    return (0, hooks_1.executeHook)(data.hooks.loops.onNext.after, data, result);
 }
 exports.normalizeNext = normalizeNext;
-//# sourceMappingURL=next.js.map
+//# sourceMappingURL=normalize-next.js.map

package/r-bridge/lang-4.x/ast/parser/xml/internal/loops/normalize-repeat.d.ts

@@ -0,0 +1,13 @@
+import type { NormalizerData } from '../../normalizer-data';
+import type { NamedXmlBasedJson } from '../../input-format';
+import type { RRepeatLoop } from '../../../../model/nodes/r-repeat-loop';
+/**
+ * Try to parse the construct as a {@link RRepeatLoop}.
+ *
+ * @param data - The data used by the parser (see {@link NormalizerData})
+ * @param repeatToken - Token which represents the `repeat` keyword
+ * @param bodyToken - The `body` of the repeat-loop
+ *
+ * @returns The parsed {@link RRepeatLoop} or `undefined` if the given construct is not a repeat-loop
+ */
+export declare function tryNormalizeRepeat(data: NormalizerData, [repeatToken, bodyToken]: [NamedXmlBasedJson, NamedXmlBasedJson]): RRepeatLoop | undefined;