@eagleoutice/flowr 1.3.11

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

@@ -0,0 +1,118 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ensureExpressionList = exports.ensureChildrenAreLhsAndRhsOrdered = exports.retrieveOpName = exports.getWithTokenType = exports.getTokenType = exports.assureTokenType = exports.revertTokenReplacement = exports.retrieveMetaStructure = exports.extractLocation = exports.objectWithArrUnwrap = void 0;
+const input_format_1 = require("./input-format");
+const range_1 = require("../../../../../../util/range");
+const assert_1 = require("../../../../../../util/assert");
+const xml_to_json_1 = require("./xml-to-json");
+/**
+ * if the passed object is an array with only one element, remove the array wrapper
+ */
+function objectWithArrUnwrap(obj) {
+    if (Array.isArray(obj)) {
+        if (obj.length !== 1) {
+            throw new input_format_1.XmlParseError(`expected only one element in the wrapped array, yet received ${JSON.stringify(obj)}`);
+        }
+        return obj[0];
+    }
+    else if (typeof obj === 'object') {
+        return obj;
+    }
+    else {
+        throw new input_format_1.XmlParseError(`expected array or object, yet received ${JSON.stringify(obj)}`);
+    }
+}
+exports.objectWithArrUnwrap = objectWithArrUnwrap;
+/**
+ * given a xml element, extract the source location of the corresponding element in the R-ast
+ */
+function extractLocation(ast) {
+    return (0, range_1.rangeFrom)(ast['line1'], ast['col1'], ast['line2'], ast['col2']);
+}
+exports.extractLocation = extractLocation;
+/**
+ * The json object that represents the input xml contains various meta-information.
+ * This function extracts the meta-information and returns it.
+ *
+ * @param config - The configuration of the parser to use to retrieve the corresponding name fields
+ * @param obj    - The json object to extract the meta-information from
+ */
+function retrieveMetaStructure(config, obj) {
+    const unwrappedObj = objectWithArrUnwrap(obj);
+    const attributes = obj[config.attr];
+    (0, assert_1.guard)(attributes !== undefined, () => `expected attributes to be defined for ${JSON.stringify(obj)}`);
+    const content = obj[config.content] ?? '';
+    const location = extractLocation(attributes);
+    return {
+        unwrappedObj,
+        location,
+        content
+    };
+}
+exports.retrieveMetaStructure = retrieveMetaStructure;
+function revertTokenReplacement(tokenMap, token) {
+    // eslint-disable-next-line @typescript-eslint/no-unnecessary-condition -- it is still necessary as we do not know if we have a replacement for the given token
+    return tokenMap[token] ?? token;
+}
+exports.revertTokenReplacement = revertTokenReplacement;
+function assureTokenType(tokenMap, obj, expectedName) {
+    const name = getTokenType(tokenMap, obj);
+    if (name !== expectedName) {
+        throw new input_format_1.XmlParseError(`expected name to be ${expectedName}, yet received ${name} for ${JSON.stringify(obj)}`);
+    }
+}
+exports.assureTokenType = assureTokenType;
+/**
+ * Extract the token-type of the given object. This is based on the knowledge, that all json objects created
+ * from the R xml have a name attached.
+ *
+ * @param tokenMap - used to revert token types (i.e., revert `xmlparsedata`)
+ * @param content  - the json object to extract the token-type from
+ */
+function getTokenType(tokenMap, content) {
+    return revertTokenReplacement(tokenMap, (0, input_format_1.getKeyGuarded)(content, xml_to_json_1.XML_NAME));
+}
+exports.getTokenType = getTokenType;
+function getWithTokenType(tokenMap, obj) {
+    return obj.map(content => ({
+        name: getTokenType(tokenMap, content),
+        content
+    }));
+}
+exports.getWithTokenType = getWithTokenType;
+function retrieveOpName(config, operator) {
+    /*
+   * only real arithmetic ops have their operation as their own name, the others identify via content
+   */
+    return operator.content[config.content];
+}
+exports.retrieveOpName = retrieveOpName;
+/**
+ * Ensure that the first child is completely before the second child.
+ *
+ * @param config - the configuration of the parser to use to retrieve the corresponding name fields
+ * @param first  - the first child which should be the lhs
+ * @param second - the second child which should be the rhs
+ */
+function ensureChildrenAreLhsAndRhsOrdered(config, first, second) {
+    const firstOtherLoc = extractLocation(first[config.attr]);
+    const secondOtherLoc = extractLocation(second[config.attr]);
+    if (!(0, range_1.rangeStartsCompletelyBefore)(firstOtherLoc, secondOtherLoc)) {
+        throw new input_format_1.XmlParseError(`expected the first child to be the lhs, yet received ${JSON.stringify(first)} & ${JSON.stringify(second)}`);
+    }
+}
+exports.ensureChildrenAreLhsAndRhsOrdered = ensureChildrenAreLhsAndRhsOrdered;
+function ensureExpressionList(node) {
+    if (node.type !== "RExpressionList" /* RType.ExpressionList */) {
+        return {
+            type: "RExpressionList" /* RType.ExpressionList */,
+            location: node.location,
+            info: node.info,
+            lexeme: undefined,
+            children: [node]
+        };
+    }
+    return node;
+}
+exports.ensureExpressionList = ensureExpressionList;
+//# sourceMappingURL=meta.js.map

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

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

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

@@ -0,0 +1,25 @@
+import { MergeableRecord } from '../../../../../util/objects';
+import { TokenMap } from '../../../../retriever';
+/**
+ * Configures the settings for the xml parser (like what names should be used to represent the given objects,
+ * and what replacements are active with `xmlparsedata` on the R-side of things).
+ *
+ * @see DEFAULT_XML_PARSER_CONFIG
+ */
+export interface XmlParserConfig extends MergeableRecord {
+    /** attributes (line, col, ...) are referenced by the given name */
+    attributeName: string;
+    /** the content (lexeme) is referenced by the given name */
+    contentName: string;
+    /** the children are referenced by the given name */
+    childrenName: string;
+    /** Mapping from xml tag name to the real operation of the node */
+    tokenMap: TokenMap;
+}
+/**
+ * Default configuration to be used for the {@link XmlParserConfig}.
+ * <p>
+ * Note, that this does not include a sensible {@link XmlParserConfig#tokenMap}, as this must be provided by the corresponding
+ * shell environment.
+ */
+export declare const DEFAULT_XML_PARSER_CONFIG: XmlParserConfig;

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

@@ -0,0 +1,16 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.DEFAULT_XML_PARSER_CONFIG = void 0;
+/**
+ * Default configuration to be used for the {@link XmlParserConfig}.
+ * <p>
+ * Note, that this does not include a sensible {@link XmlParserConfig#tokenMap}, as this must be provided by the corresponding
+ * shell environment.
+ */
+exports.DEFAULT_XML_PARSER_CONFIG = {
+    attributeName: '@a',
+    contentName: '@v',
+    childrenName: '@c',
+    tokenMap: { /* this should not be used, but just so that we can omit null-checks */}
+};
+//# sourceMappingURL=config.js.map

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

@@ -0,0 +1,22 @@
+import { MergeableRecord } from '../../../../../util/objects';
+import { DeepReadonly } from 'ts-essentials';
+import { XmlParserConfig } from './config';
+import { XmlParserHooks } from './hooks';
+import { SourceRange } from '../../../../../util/range';
+/**
+ * Contains all information populated and present during parsing and normalization of the R AST.
+ */
+export interface ParserData extends MergeableRecord {
+    /** @see XmlParserConfig */
+    readonly config: DeepReadonly<XmlParserConfig>;
+    /** @see XmlParserHooks */
+    readonly hooks: DeepReadonly<XmlParserHooks>;
+    /**
+   * The currently active source range during parsing, i.e. the full range of the current element.
+   */
+    currentRange: SourceRange | undefined;
+    /**
+   * The currently active lexeme during parsing, i.e. the full lexeme of the current element.
+   */
+    currentLexeme: string | undefined;
+}

package/r-bridge/lang-4.x/ast/parser/xml/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/hooks.d.ts

@@ -0,0 +1,292 @@
+import { NamedXmlBasedJson, XmlBasedJson } from './input-format';
+import { RNumber, NoInfo, RBinaryOp, RComment, RForLoop, RFunctionCall, RIfThenElse, RNode, RRepeatLoop, RString, RUnaryOp, RWhileLoop, RSymbol, RLogical, BinaryOperatorFlavor, RParameter, RFunctionDefinition, RArgument, UnaryOperatorFlavor, RBreak, RNext, RAccess, RLineDirective, RPipe } from '../../model';
+import { RNa } from '../../../values';
+import { ParserData } from './data';
+import { DeepReadonly, DeepRequired } from 'ts-essentials';
+/** Denotes that if you return `undefined`, the parser will automatically take the original arguments (unchanged) */
+type AutoIfOmit<T> = T | undefined | void;
+/**
+ * Hooks for every action the parser does. They can process the object before and after the actual parsing.
+ *
+ * There are two main hooks:
+ * <ul>
+ *   <li><strong>before:</strong> can transform the inputs to the function and is called before construction of the normalized ast. However, it can be called after initial checks are performed. </li>
+ *   <li><strong>after:</strong> can transform the result of the function and is called after construction of the normalized ast. </li>
+ * </ul>
+ * Furthermore, for events that "try" to identify a structure, there is a third hook:
+ * <ul>
+ *   <li><strong>unknown:</strong> is called if the structure could not be identified. </li>
+ * </ul>
+ *
+ * For those marked with {@link AutoIfOmit} you can return `undefined` to automatically take the original arguments (unchanged).
+ * <p>
+ * Use {@link executeHook} and {@link executeUnknownHook} to execute the hooks.
+ * <p>
+ * Please note, that there is no guarantee, that a hook is not using any other. For example, {@link tryNormalizeIfThen} is used by {@link tryNormalizeIfThenElse}.
+ */
+export interface XmlParserHooks {
+    values: {
+        /** {@link normalizeNumber} */
+        onNumber: {
+            before(data: ParserData, inputObj: XmlBasedJson): AutoIfOmit<XmlBasedJson>;
+            after(data: ParserData, result: RNumber | RLogical | RSymbol<NoInfo, typeof RNa>): AutoIfOmit<RNumber | RLogical | RSymbol<NoInfo, typeof RNa>>;
+        };
+        /** {@link parseString} */
+        onString: {
+            before(data: ParserData, inputObj: XmlBasedJson): AutoIfOmit<XmlBasedJson>;
+            after(data: ParserData, result: RString): AutoIfOmit<RString>;
+        };
+        /** {@link tryNormalizeSymbol} */
+        onSymbol: {
+            /**
+       * triggered if {@link tryNormalizeSymbol} could not determine the namespace and or symbol.
+       * Can emit non-symbol values easily due to special symbols like `T`.
+       */
+            unknown(data: ParserData, inputObjs: NamedXmlBasedJson[]): AutoIfOmit<RSymbol | undefined>;
+            before(data: ParserData, inputObjs: NamedXmlBasedJson[]): AutoIfOmit<NamedXmlBasedJson[]>;
+            after(data: ParserData, result: RSymbol | undefined): AutoIfOmit<RSymbol | undefined>;
+        };
+    };
+    /** {@link tryNormalizeAccess} */
+    onAccess: {
+        /**
+     * triggered if {@link tryNormalizeAccess} could not determine the access
+     */
+        unknown(data: ParserData, inputObjs: NamedXmlBasedJson[]): AutoIfOmit<RAccess | undefined>;
+        before(data: ParserData, inputObjs: NamedXmlBasedJson[]): AutoIfOmit<NamedXmlBasedJson[]>;
+        after(data: ParserData, result: RAccess): AutoIfOmit<RAccess>;
+    };
+    other: {
+        /** {@link normalizeComment} */
+        onComment: {
+            before(data: ParserData, inputObj: XmlBasedJson): AutoIfOmit<XmlBasedJson>;
+            after(data: ParserData, result: RComment): AutoIfOmit<RComment>;
+        };
+        /** {@link normalizeLineDirective} */
+        onLineDirective: {
+            before(data: ParserData, inputObj: XmlBasedJson): AutoIfOmit<XmlBasedJson>;
+            after(data: ParserData, result: RLineDirective | RComment): AutoIfOmit<RLineDirective | RComment>;
+        };
+    };
+    operators: {
+        /** {@link tryNormalizeBinary}, includes {@link RPipe} and {@link RFunctionCall} in case of special infix binary operations */
+        onBinary: {
+            /** triggered if {@link tryNormalizeBinary} could not find a matching operator, you probably still want to return `undefined` */
+            unknown(data: ParserData, input: {
+                lhs: NamedXmlBasedJson;
+                operator: NamedXmlBasedJson;
+                rhs: NamedXmlBasedJson;
+            }): AutoIfOmit<RNode | undefined>;
+            before(data: ParserData, input: {
+                flavor: BinaryOperatorFlavor | 'special' | 'pipe';
+                lhs: NamedXmlBasedJson;
+                operator: NamedXmlBasedJson;
+                rhs: NamedXmlBasedJson;
+            }): AutoIfOmit<{
+                flavor: BinaryOperatorFlavor | 'special' | 'pipe';
+                lhs: NamedXmlBasedJson;
+                operator: NamedXmlBasedJson;
+                rhs: NamedXmlBasedJson;
+            }>;
+            after(data: ParserData, result: RFunctionCall | RBinaryOp | RPipe): AutoIfOmit<RFunctionCall | RBinaryOp | RPipe>;
+        };
+        /** {@link tryNormalizeUnary} */
+        onUnary: {
+            /** triggered if {@link tryNormalizeUnary} could not find a matching operator, you probably still want to return `undefined` */
+            unknown(data: ParserData, input: {
+                operator: NamedXmlBasedJson;
+                operand: NamedXmlBasedJson;
+            }): AutoIfOmit<RNode | undefined>;
+            before(data: ParserData, input: {
+                flavor: UnaryOperatorFlavor;
+                operator: NamedXmlBasedJson;
+                operand: NamedXmlBasedJson;
+            }): AutoIfOmit<{
+                flavor: UnaryOperatorFlavor;
+                operator: NamedXmlBasedJson;
+                operand: NamedXmlBasedJson;
+            }>;
+            after(data: ParserData, result: RUnaryOp): AutoIfOmit<RUnaryOp>;
+        };
+    };
+    loops: {
+        /** {@link tryNormalizeFor} */
+        onForLoop: {
+            /** triggered if {@link tryNormalizeFor} could not detect a for-loop, you probably still want to return `undefined` */
+            unknown(data: ParserData, input: {
+                forToken: NamedXmlBasedJson;
+                condition: NamedXmlBasedJson;
+                body: NamedXmlBasedJson;
+            }): AutoIfOmit<RForLoop | undefined>;
+            before(data: ParserData, input: {
+                forToken: NamedXmlBasedJson;
+                condition: NamedXmlBasedJson;
+                body: NamedXmlBasedJson;
+            }): AutoIfOmit<{
+                forToken: NamedXmlBasedJson;
+                condition: NamedXmlBasedJson;
+                body: NamedXmlBasedJson;
+            }>;
+            after(data: ParserData, result: RForLoop): AutoIfOmit<RForLoop>;
+        };
+        /** {@link tryNormalizeRepeat} */
+        onRepeatLoop: {
+            /** triggered if {@link tryNormalizeRepeat} could not detect a repeat-loop, you probably still want to return `undefined` */
+            unknown(data: ParserData, input: {
+                repeatToken: NamedXmlBasedJson;
+                body: NamedXmlBasedJson;
+            }): AutoIfOmit<RRepeatLoop | undefined>;
+            before(data: ParserData, input: {
+                repeatToken: NamedXmlBasedJson;
+                body: NamedXmlBasedJson;
+            }): AutoIfOmit<{
+                repeatToken: NamedXmlBasedJson;
+                body: NamedXmlBasedJson;
+            }>;
+            after(data: ParserData, result: RRepeatLoop): AutoIfOmit<RRepeatLoop>;
+        };
+        /** {@link tryNormalizeWhile} */
+        onWhileLoop: {
+            /** triggered if {@link tryNormalizeWhile} could not detect a while-loop, you probably still want to return `undefined` */
+            unknown(data: ParserData, input: {
+                whileToken: NamedXmlBasedJson;
+                leftParen: NamedXmlBasedJson;
+                condition: NamedXmlBasedJson;
+                rightParen: NamedXmlBasedJson;
+                body: NamedXmlBasedJson;
+            }): AutoIfOmit<RWhileLoop | undefined>;
+            before(data: ParserData, input: {
+                whileToken: NamedXmlBasedJson;
+                leftParen: NamedXmlBasedJson;
+                condition: NamedXmlBasedJson;
+                rightParen: NamedXmlBasedJson;
+                body: NamedXmlBasedJson;
+            }): AutoIfOmit<{
+                whileToken: NamedXmlBasedJson;
+                leftParen: NamedXmlBasedJson;
+                condition: NamedXmlBasedJson;
+                rightParen: NamedXmlBasedJson;
+                body: NamedXmlBasedJson;
+            }>;
+            after(data: ParserData, result: RWhileLoop): AutoIfOmit<RWhileLoop>;
+        };
+        /** {@link normalizeBreak} */
+        onBreak: {
+            before(data: ParserData, input: XmlBasedJson): AutoIfOmit<XmlBasedJson>;
+            after(data: ParserData, result: RBreak): AutoIfOmit<RBreak>;
+        };
+        onNext: {
+            before(data: ParserData, input: XmlBasedJson): AutoIfOmit<XmlBasedJson>;
+            after(data: ParserData, result: RNext): AutoIfOmit<RNext>;
+        };
+    };
+    functions: {
+        /** {@link tryNormalizeFunctionDefinition} */
+        onFunctionDefinition: {
+            /** triggered if {@link tryNormalizeFunctionDefinition} could not detect a function definition, you probably still want to return `undefined` */
+            unknown(data: ParserData, mappedWithName: NamedXmlBasedJson[]): AutoIfOmit<RFunctionDefinition | undefined>;
+            before(data: ParserData, mappedWithName: NamedXmlBasedJson[]): AutoIfOmit<NamedXmlBasedJson[]>;
+            after(data: ParserData, result: RFunctionDefinition): AutoIfOmit<RFunctionDefinition>;
+        };
+        /** {@link tryNormalizeParameter} */
+        onParameter: {
+            /** triggered if {@link tryNormalizeParameter} could not detect a parameter, you probably still want to return `undefined` */
+            unknown(data: ParserData, mappedWithName: NamedXmlBasedJson[]): AutoIfOmit<RParameter | undefined>;
+            before(data: ParserData, mappedWithName: NamedXmlBasedJson[]): AutoIfOmit<NamedXmlBasedJson[]>;
+            after(data: ParserData, result: RParameter): AutoIfOmit<RParameter>;
+        };
+        /** {@link tryNormalizeFunctionCall} */
+        onFunctionCall: {
+            /** triggered if {@link tryNormalizeFunctionCall} could not detect a function call, you probably still want to return `undefined` */
+            unknown(data: ParserData, mappedWithName: NamedXmlBasedJson[]): AutoIfOmit<RFunctionCall | RNext | RBreak | undefined>;
+            before(data: ParserData, mappedWithName: NamedXmlBasedJson[]): AutoIfOmit<NamedXmlBasedJson[]>;
+            after(data: ParserData, result: RFunctionCall | RNext | RBreak): AutoIfOmit<RFunctionCall | RNext | RBreak>;
+        };
+        /** {@link tryToNormalizeArgument} */
+        onArgument: {
+            /** triggered if {@link tryToNormalizeArgument} could not detect an argument, you probably still want to return `undefined` */
+            unknown(data: ParserData, mappedWithName: NamedXmlBasedJson[]): AutoIfOmit<RArgument | undefined>;
+            before(data: ParserData, mappedWithName: NamedXmlBasedJson[]): AutoIfOmit<NamedXmlBasedJson[]>;
+            after(data: ParserData, result: RArgument): AutoIfOmit<RArgument>;
+        };
+    };
+    expression: {
+        /** {@link normalizeExpression} */
+        onExpression: {
+            /** *Warning:* can be a function call/definition as well, is not known when issuing before! */
+            before(data: ParserData, inputObj: XmlBasedJson): AutoIfOmit<XmlBasedJson>;
+            after(data: ParserData, result: RNode): AutoIfOmit<RNode>;
+        };
+    };
+    control: {
+        /** {@link tryNormalizeIfThen}, triggered by {@link onIfThenElse} as well */
+        onIfThen: {
+            /** triggered if {@link tryNormalizeIfThen} could not detect an if-then, you probably still want to return `undefined` */
+            unknown(data: ParserData, tokens: [
+                ifToken: NamedXmlBasedJson,
+                leftParen: NamedXmlBasedJson,
+                condition: NamedXmlBasedJson,
+                rightParen: NamedXmlBasedJson,
+                then: NamedXmlBasedJson
+            ]): AutoIfOmit<RIfThenElse | undefined>;
+            before(data: ParserData, tokens: [
+                ifToken: NamedXmlBasedJson,
+                leftParen: NamedXmlBasedJson,
+                condition: NamedXmlBasedJson,
+                rightParen: NamedXmlBasedJson,
+                then: NamedXmlBasedJson
+            ]): AutoIfOmit<[
+                ifToken: NamedXmlBasedJson,
+                leftParen: NamedXmlBasedJson,
+                condition: NamedXmlBasedJson,
+                rightParen: NamedXmlBasedJson,
+                then: NamedXmlBasedJson
+            ]>;
+            after(data: ParserData, result: RIfThenElse): AutoIfOmit<RIfThenElse>;
+        };
+        /** {@link tryNormalizeIfThenElse}, triggers {@link onIfThen} */
+        onIfThenElse: {
+            /** triggered if {@link tryNormalizeIfThenElse} could not detect an if-then-else, you probably still want to return `undefined`, this is probably called as a consequence of the unknown hook of if-then */
+            unknown(data: ParserData, tokens: [
+                ifToken: NamedXmlBasedJson,
+                leftParen: NamedXmlBasedJson,
+                condition: NamedXmlBasedJson,
+                rightParen: NamedXmlBasedJson,
+                then: NamedXmlBasedJson,
+                elseToken: NamedXmlBasedJson,
+                elseBlock: NamedXmlBasedJson
+            ]): AutoIfOmit<RIfThenElse | undefined>;
+            /** be aware, that the if-then part triggers another hook! */
+            before(data: ParserData, tokens: [
+                ifToken: NamedXmlBasedJson,
+                leftParen: NamedXmlBasedJson,
+                condition: NamedXmlBasedJson,
+                rightParen: NamedXmlBasedJson,
+                then: NamedXmlBasedJson,
+                elseToken: NamedXmlBasedJson,
+                elseBlock: NamedXmlBasedJson
+            ]): AutoIfOmit<[
+                ifToken: NamedXmlBasedJson,
+                leftParen: NamedXmlBasedJson,
+                condition: NamedXmlBasedJson,
+                rightParen: NamedXmlBasedJson,
+                then: NamedXmlBasedJson,
+                elseToken: NamedXmlBasedJson,
+                elseBlock: NamedXmlBasedJson
+            ]>;
+            after(data: ParserData, result: RIfThenElse): AutoIfOmit<RIfThenElse>;
+        };
+    };
+}
+/**
+ * simple (rather type-wise unsafe ^^) function you can use to execute hooks and deal with {@link AutoIfOmit}
+ *
+ * @see executeUnknownHook
+ */
+export declare function executeHook<T, R>(hook: (data: ParserData, input: T) => AutoIfOmit<R>, data: ParserData, input: T): R;
+/**
+ * @see executeHook
+ */
+export declare function executeUnknownHook<T, R>(hook: (data: ParserData, input: T) => AutoIfOmit<R>, data: ParserData, input: T): Exclude<AutoIfOmit<R>, void>;
+export declare const DEFAULT_PARSER_HOOKS: DeepReadonly<DeepRequired<XmlParserHooks>>;
+export {};

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

@@ -0,0 +1,136 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.DEFAULT_PARSER_HOOKS = exports.executeUnknownHook = exports.executeHook = void 0;
+/* eslint-disable -- hooks are unsafe */
+/**
+ * simple (rather type-wise unsafe ^^) function you can use to execute hooks and deal with {@link AutoIfOmit}
+ *
+ * @see executeUnknownHook
+ */
+function executeHook(hook, data, input) {
+    const result = hook(data, input);
+    if (result === undefined) {
+        return input;
+    }
+    return result;
+}
+exports.executeHook = executeHook;
+/**
+ * @see executeHook
+ */
+function executeUnknownHook(hook, data, input) {
+    return hook(data, input);
+}
+exports.executeUnknownHook = executeUnknownHook;
+/* eslint-enable */
+const doNothing = () => undefined;
+exports.DEFAULT_PARSER_HOOKS = {
+    values: {
+        onNumber: {
+            before: doNothing,
+            after: doNothing
+        },
+        onString: {
+            before: doNothing,
+            after: doNothing
+        },
+        onSymbol: {
+            unknown: doNothing,
+            before: doNothing,
+            after: doNothing
+        }
+    },
+    onAccess: {
+        unknown: doNothing,
+        before: doNothing,
+        after: doNothing
+    },
+    other: {
+        onComment: {
+            before: doNothing,
+            after: doNothing
+        },
+        onLineDirective: {
+            before: doNothing,
+            after: doNothing
+        }
+    },
+    control: {
+        onIfThen: {
+            unknown: doNothing,
+            before: doNothing,
+            after: doNothing
+        },
+        onIfThenElse: {
+            unknown: doNothing,
+            before: doNothing,
+            after: doNothing
+        }
+    },
+    loops: {
+        onForLoop: {
+            unknown: doNothing,
+            before: doNothing,
+            after: doNothing
+        },
+        onRepeatLoop: {
+            unknown: doNothing,
+            before: doNothing,
+            after: doNothing
+        },
+        onWhileLoop: {
+            unknown: doNothing,
+            before: doNothing,
+            after: doNothing
+        },
+        onBreak: {
+            before: doNothing,
+            after: doNothing
+        },
+        onNext: {
+            before: doNothing,
+            after: doNothing
+        }
+    },
+    operators: {
+        onBinary: {
+            unknown: doNothing,
+            before: doNothing,
+            after: doNothing
+        },
+        onUnary: {
+            unknown: doNothing,
+            before: doNothing,
+            after: doNothing
+        }
+    },
+    functions: {
+        onFunctionDefinition: {
+            unknown: doNothing,
+            before: doNothing,
+            after: doNothing
+        },
+        onParameter: {
+            unknown: doNothing,
+            before: doNothing,
+            after: doNothing
+        },
+        onFunctionCall: {
+            unknown: doNothing,
+            before: doNothing,
+            after: doNothing
+        },
+        onArgument: {
+            unknown: doNothing,
+            before: doNothing,
+            after: doNothing
+        },
+    },
+    expression: {
+        onExpression: {
+            before: doNothing,
+            after: doNothing
+        }
+    }
+};
+//# sourceMappingURL=hooks.js.map

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

@@ -0,0 +1,5 @@
+export * from './data';
+export * from './hooks';
+export * from './config';
+export * from './parser';
+export * from './input-format';