@eagleoutice/flowr 1.3.11

package/r-bridge/lang-4.x/ast/parser/xml/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("../../input-format");
+const meta_1 = require("../meta");
+const parser_1 = require("../../parser");
+const structure_1 = require("../structure");
+const hooks_1 = require("../../hooks");
+function tryNormalizeWhile(data, whileToken, leftParen, condition, rightParen, body) {
+    if (whileToken.name !== "WHILE" /* RawRType.While */) {
+        parser_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)}`);
+    }
+    parser_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

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

@@ -0,0 +1,50 @@
+import { NamedXmlBasedJson, XmlBasedJson } from '../input-format';
+import { SourceRange } from '../../../../../../util/range';
+import { XmlParserConfig } from '../config';
+import { RawRType, RExpressionList, RNode } from '../../../model';
+/**
+ * if the passed object is an array with only one element, remove the array wrapper
+ */
+export declare function objectWithArrUnwrap(obj: XmlBasedJson[] | XmlBasedJson): XmlBasedJson;
+/**
+ * given a xml element, extract the source location of the corresponding element in the R-ast
+ */
+export declare function extractLocation(ast: XmlBasedJson): SourceRange;
+/**
+ * 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
+ */
+export declare function retrieveMetaStructure(config: XmlParserConfig, obj: XmlBasedJson): {
+    /** the obj passed in, but potentially without surrounding array wrappers (see {@link objectWithArrUnwrap}) */
+    unwrappedObj: XmlBasedJson;
+    /** location information of the corresponding R-ast element */
+    location: SourceRange;
+    content: string;
+};
+export declare function revertTokenReplacement(tokenMap: XmlParserConfig['tokenMap'], token: string): string;
+export declare function assureTokenType(tokenMap: XmlParserConfig['tokenMap'], obj: XmlBasedJson, expectedName: RawRType): void;
+/**
+ * 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
+ */
+export declare function getTokenType(tokenMap: XmlParserConfig['tokenMap'], content: XmlBasedJson): RawRType;
+export declare function getWithTokenType(tokenMap: XmlParserConfig['tokenMap'], obj: XmlBasedJson[]): {
+    name: RawRType;
+    content: XmlBasedJson;
+}[];
+export declare function retrieveOpName(config: XmlParserConfig, operator: NamedXmlBasedJson): string;
+/**
+ * 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
+ */
+export declare function ensureChildrenAreLhsAndRhsOrdered(config: XmlParserConfig, first: XmlBasedJson, second: XmlBasedJson): void;
+export declare function ensureExpressionList<Info>(node: RNode<Info>): RExpressionList<Info>;

package/r-bridge/lang-4.x/ast/parser/xml/internal/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");
+/**
+ * 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) {
+    const { line1, col1, line2, col2 } = (0, input_format_1.getKeysGuarded)(ast, 'line1', 'col1', 'line2', 'col2');
+    return (0, range_1.rangeFrom)(line1, col1, line2, 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.attributeName];
+    const content = obj[config.contentName] ?? '';
+    (0, assert_1.guard)(attributes !== undefined, () => `expected attributes to be defined for ${JSON.stringify(obj)}`);
+    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.getKeysGuarded)(content, '#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.contentName];
+}
+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.attributeName]);
+    const secondOtherLoc = extractLocation(second[config.attributeName]);
+    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/internal/operators/binary.d.ts

@@ -0,0 +1,8 @@
+import { NamedXmlBasedJson } from '../../input-format';
+import { ParserData } from '../../data';
+import { RNode } from '../../../../model';
+/**
+ * Parsing binary operations includes the pipe, even though the produced PIPE construct is not a binary operation,
+ * to ensure it is handled separately from the others (especially in the combination of a pipe bind)
+ */
+export declare function tryNormalizeBinary(data: ParserData, lhs: NamedXmlBasedJson, operator: NamedXmlBasedJson, rhs: NamedXmlBasedJson): RNode | undefined;

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

@@ -0,0 +1,162 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.tryNormalizeBinary = void 0;
+const input_format_1 = require("../../input-format");
+const parser_1 = require("../../parser");
+const meta_1 = require("../meta");
+const special_1 = require("./special");
+const structure_1 = require("../structure");
+const model_1 = require("../../../../model");
+const hooks_1 = require("../../hooks");
+const assert_1 = require("../../../../../../../util/assert");
+/**
+ * Parsing binary operations includes the pipe, even though the produced PIPE construct is not a binary operation,
+ * to ensure it is handled separately from the others (especially in the combination of a pipe bind)
+ */
+function tryNormalizeBinary(data, lhs, operator, rhs) {
+    parser_1.parseLog.trace(`binary op for ${lhs.name} [${operator.name}] ${rhs.name}`);
+    let flavor;
+    if ("SPECIAL" /* RawRType.Special */ === operator.name) {
+        flavor = 'special';
+    }
+    else if (model_1.ArithmeticOperatorsRAst.has(operator.name)) {
+        flavor = 'arithmetic';
+    }
+    else if (model_1.ComparisonOperatorsRAst.has(operator.name)) {
+        flavor = 'comparison';
+    }
+    else if (model_1.LogicalOperatorsRAst.has(operator.name)) {
+        flavor = 'logical';
+    }
+    else if (model_1.ModelFormulaOperatorsRAst.has(operator.name)) {
+        flavor = 'model formula';
+    }
+    else if (model_1.AssignmentsRAst.has(operator.name)) {
+        flavor = 'assignment';
+    }
+    else if (operator.name === "PIPE" /* RawRType.Pipe */) {
+        flavor = 'pipe';
+    }
+    else {
+        return (0, hooks_1.executeUnknownHook)(data.hooks.operators.onBinary.unknown, data, { lhs, operator, rhs });
+    }
+    return parseBinaryOp(data, flavor, lhs, operator, rhs);
+}
+exports.tryNormalizeBinary = tryNormalizeBinary;
+function parseBinaryOp(data, flavor, lhs, operator, rhs) {
+    parser_1.parseLog.debug(`[binary op] trying to parse ${flavor}`);
+    ({ flavor, lhs, rhs, operator } = (0, hooks_1.executeHook)(data.hooks.operators.onBinary.before, data, { flavor, lhs, operator, rhs }));
+    (0, meta_1.ensureChildrenAreLhsAndRhsOrdered)(data.config, lhs.content, rhs.content);
+    let parsedLhs = (0, structure_1.tryNormalizeSingleNode)(data, lhs);
+    let parsedRhs = (0, structure_1.tryNormalizeSingleNode)(data, rhs);
+    if (parsedLhs.type === "RDelimiter" /* RType.Delimiter */ || parsedRhs.type === "RDelimiter" /* RType.Delimiter */) {
+        throw new input_format_1.XmlParseError(`unexpected under-sided binary op, received ${JSON.stringify([parsedLhs, parsedRhs])} for ${JSON.stringify([lhs, operator, rhs])}`);
+    }
+    const operationName = (0, meta_1.retrieveOpName)(data.config, operator);
+    // special support for strings in assignments
+    if (flavor === 'assignment') {
+        [parsedLhs, parsedRhs] = processLhsAndRhsForAssignment(data, operationName, parsedLhs, parsedRhs);
+    }
+    const { location, content } = (0, meta_1.retrieveMetaStructure)(data.config, operator.content);
+    if (flavor === 'special') {
+        flavor = (0, special_1.identifySpecialOp)(content);
+    }
+    if (flavor === 'special') {
+        (0, assert_1.guard)(parsedLhs.location !== undefined && parsedLhs.lexeme !== undefined && parsedRhs.location !== undefined && parsedRhs.lexeme !== undefined, () => `special op lhs and rhs must have a locations and lexemes, but ${JSON.stringify(parsedLhs)} and ${JSON.stringify(parsedRhs)})`);
+        // parse as infix function call!
+        const result = {
+            type: "RFunctionCall" /* RType.FunctionCall */,
+            flavor: 'named',
+            infixSpecial: true,
+            lexeme: data.currentLexeme ?? content,
+            location,
+            functionName: {
+                type: "RSymbol" /* RType.Symbol */,
+                location,
+                lexeme: content,
+                content,
+                namespace: undefined,
+                info: {}
+            },
+            arguments: [
+                {
+                    type: "RArgument" /* RType.Argument */,
+                    location: parsedLhs.location,
+                    value: parsedLhs,
+                    name: undefined,
+                    lexeme: parsedLhs.lexeme,
+                    info: {}
+                },
+                {
+                    type: "RArgument" /* RType.Argument */,
+                    location: parsedRhs.location,
+                    value: parsedRhs,
+                    name: undefined,
+                    lexeme: parsedRhs.lexeme,
+                    info: {}
+                }
+            ],
+            info: {}
+        };
+        return (0, hooks_1.executeHook)(data.hooks.operators.onBinary.after, data, result);
+    }
+    let result;
+    if (flavor === 'pipe') {
+        (0, assert_1.guard)(parsedLhs.location !== undefined, () => `pipe lhs must have a location, but ${JSON.stringify(parsedLhs)})`);
+        (0, assert_1.guard)(parsedLhs.lexeme !== undefined, () => `pipe lhs must have a full lexeme, but ${JSON.stringify(parsedLhs)})`);
+        result = {
+            type: "RPipe" /* RType.Pipe */,
+            location,
+            lhs: {
+                type: "RArgument" /* RType.Argument */,
+                location: parsedLhs.location,
+                value: parsedLhs,
+                name: undefined,
+                lexeme: parsedLhs.lexeme,
+                info: {}
+            },
+            rhs: parsedRhs,
+            lexeme: content,
+            info: {
+                fullRange: data.currentRange,
+                additionalTokens: [],
+                fullLexeme: data.currentLexeme
+            }
+        };
+    }
+    else {
+        result = {
+            type: "RBinaryOp" /* RType.BinaryOp */,
+            flavor,
+            location,
+            lhs: parsedLhs,
+            rhs: parsedRhs,
+            operator: operationName,
+            lexeme: content,
+            info: {
+                fullRange: data.currentRange,
+                additionalTokens: [],
+                fullLexeme: data.currentLexeme
+            }
+        };
+    }
+    return (0, hooks_1.executeHook)(data.hooks.operators.onBinary.after, data, result);
+}
+function processLhsAndRhsForAssignment(data, opName, parsedLhs, parsedRhs) {
+    const isRhs = opName === '->' || opName === '->>';
+    const assigned = isRhs ? parsedRhs : parsedLhs;
+    if (assigned.type !== "RString" /* RType.String */) {
+        return [parsedLhs, parsedRhs];
+    }
+    // update the assigned value to be parsed as a symbol
+    const result = {
+        type: "RSymbol" /* RType.Symbol */,
+        lexeme: assigned.lexeme,
+        location: assigned.location,
+        content: assigned.content.str,
+        namespace: undefined,
+        info: assigned.info
+    };
+    return isRhs ? [parsedLhs, result] : [result, parsedRhs];
+}
+//# sourceMappingURL=binary.js.map

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

@@ -0,0 +1,3 @@
+export * from './unary';
+export * from './binary';
+export * from './special';

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

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

@@ -0,0 +1,6 @@
+import { BinaryOperatorFlavor } from '../../../../model';
+/**
+ * Identify the flavor of a given operator, as we do not really have a use for "special"
+ * operators within our internal AST.
+ */
+export declare function identifySpecialOp(content: string): BinaryOperatorFlavor | 'special';

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

@@ -0,0 +1,24 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.identifySpecialOp = void 0;
+const model_1 = require("../../../../model");
+/**
+ * Identify the flavor of a given operator, as we do not really have a use for "special"
+ * operators within our internal AST.
+ */
+function identifySpecialOp(content) {
+    if (model_1.ComparisonOperatorsRAst.has(content)) {
+        return 'comparison';
+    }
+    else if (model_1.LogicalOperatorsRAst.has(content)) {
+        return 'logical';
+    }
+    else if (model_1.ArithmeticOperatorsRAst.has(content)) {
+        return 'arithmetic';
+    }
+    else {
+        return 'special';
+    }
+}
+exports.identifySpecialOp = identifySpecialOp;
+//# sourceMappingURL=special.js.map

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

@@ -0,0 +1,13 @@
+import { NamedXmlBasedJson } from '../../input-format';
+import { ParserData } from '../../data';
+import { RNode } from '../../../../model';
+/**
+ * Parses the construct as a {@link RUnaryOp} (automatically identifies the flavor).
+ *
+ * @param data     - The data used by the parser (see {@link ParserData})
+ * @param operator - The operator token
+ * @param operand  - The operand of the unary operator
+ *
+ * @returns The parsed {@link RUnaryOp} or `undefined` if the given construct is not a unary operator
+ */
+export declare function tryNormalizeUnary(data: ParserData, operator: NamedXmlBasedJson, operand: NamedXmlBasedJson): RNode | undefined;

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

@@ -0,0 +1,59 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.tryNormalizeUnary = void 0;
+const meta_1 = require("../meta");
+const parser_1 = require("../../parser");
+const structure_1 = require("../structure");
+const assert_1 = require("../../../../../../../util/assert");
+const model_1 = require("../../../../model");
+const hooks_1 = require("../../hooks");
+/**
+ * Parses the construct as a {@link RUnaryOp} (automatically identifies the flavor).
+ *
+ * @param data     - The data used by the parser (see {@link ParserData})
+ * @param operator - The operator token
+ * @param operand  - The operand of the unary operator
+ *
+ * @returns The parsed {@link RUnaryOp} or `undefined` if the given construct is not a unary operator
+ */
+function tryNormalizeUnary(data, operator, operand) {
+    parser_1.parseLog.trace(`unary op for ${operator.name} ${operand.name}`);
+    let flavor;
+    if (model_1.ArithmeticOperatorsRAst.has(operator.name)) {
+        flavor = 'arithmetic';
+    }
+    else if (model_1.LogicalOperatorsRAst.has(operator.name)) {
+        flavor = 'logical';
+    }
+    else if (model_1.ModelFormulaOperatorsRAst.has(operator.name)) {
+        flavor = 'model formula';
+    }
+    else {
+        return (0, hooks_1.executeUnknownHook)(data.hooks.operators.onUnary.unknown, data, { operator, operand });
+    }
+    return parseUnaryOp(data, flavor, operator, operand);
+}
+exports.tryNormalizeUnary = tryNormalizeUnary;
+function parseUnaryOp(data, flavor, operator, operand) {
+    parser_1.parseLog.debug(`[unary op] parse ${flavor}`); // <- semicolon sadly required for not miss-interpreting the destructuring match as call
+    ({ flavor, operator, operand } = (0, hooks_1.executeHook)(data.hooks.operators.onUnary.before, data, { flavor, operator, operand }));
+    const parsedOperand = (0, structure_1.tryNormalizeSingleNode)(data, operand);
+    (0, assert_1.guard)(parsedOperand.type !== "RDelimiter" /* RType.Delimiter */, () => 'unexpected under-sided unary op');
+    const operationName = (0, meta_1.retrieveOpName)(data.config, operator);
+    const { location, content } = (0, meta_1.retrieveMetaStructure)(data.config, operator.content);
+    const result = {
+        type: "RUnaryOp" /* RType.UnaryOp */,
+        flavor,
+        location,
+        operator: operationName,
+        lexeme: content,
+        operand: parsedOperand,
+        info: {
+            fullRange: data.currentRange,
+            additionalTokens: [],
+            fullLexeme: data.currentLexeme
+        }
+    };
+    return (0, hooks_1.executeHook)(data.hooks.operators.onUnary.after, data, result);
+}
+//# sourceMappingURL=unary.js.map

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

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

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

@@ -0,0 +1,34 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.normalizeComment = void 0;
+const parser_1 = require("../../parser");
+const meta_1 = require("../meta");
+const assert_1 = require("../../../../../../../util/assert");
+const hooks_1 = require("../../hooks");
+/**
+ * Normalize the given object as an R comment.
+ * This requires you to check the corresponding name beforehand.
+ *
+ * @param data - The data used by the parser (see {@link ParserData})
+ * @param obj  - The json object to extract the meta-information from
+ */
+function normalizeComment(data, obj) {
+    parser_1.parseLog.debug('[comment]');
+    obj = (0, hooks_1.executeHook)(data.hooks.other.onComment.before, data, obj);
+    const { location, content } = (0, meta_1.retrieveMetaStructure)(data.config, obj);
+    (0, assert_1.guard)(content.startsWith('#'), 'comment must start with #');
+    const result = {
+        type: "RComment" /* RType.Comment */,
+        location,
+        content: content.slice(1),
+        lexeme: content,
+        info: {
+            fullRange: data.currentRange,
+            additionalTokens: [],
+            fullLexeme: content
+        }
+    };
+    return (0, hooks_1.executeHook)(data.hooks.other.onComment.after, data, result);
+}
+exports.normalizeComment = normalizeComment;
+//# sourceMappingURL=comment.js.map

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

@@ -0,0 +1 @@
+export * from './comment';

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

@@ -0,0 +1,18 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __exportStar = (this && this.__exportStar) || function(m, exports) {
+    for (var p in m) if (p !== "default" && !Object.prototype.hasOwnProperty.call(exports, p)) __createBinding(exports, m, p);
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+__exportStar(require("./comment"), exports);
+//# sourceMappingURL=index.js.map

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

@@ -0,0 +1,12 @@
+import { XmlBasedJson } from '../../input-format';
+import { RComment, RLineDirective } from '../../../../model';
+import { ParserData } from '../../data';
+/**
+ * Normalize the given object as an R line directive (`#line <number> "<file>"`).
+ * This requires you to check the corresponding name beforehand.
+ * If the given object turns out to be no line directive, this returns a normal comment instead.
+ *
+ * @param data - The data used by the parser (see {@link ParserData})
+ * @param obj  - The json object to extract the meta-information from
+ */
+export declare function normalizeLineDirective(data: ParserData, obj: XmlBasedJson): RLineDirective | RComment;

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

@@ -0,0 +1,55 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.normalizeLineDirective = void 0;
+const parser_1 = require("../../parser");
+const meta_1 = require("../meta");
+const assert_1 = require("../../../../../../../util/assert");
+const hooks_1 = require("../../hooks");
+const LineDirectiveRegex = /^#line\s+(\d+)\s+"([^"]+)"\s*$/;
+/**
+ * Normalize the given object as an R line directive (`#line <number> "<file>"`).
+ * This requires you to check the corresponding name beforehand.
+ * If the given object turns out to be no line directive, this returns a normal comment instead.
+ *
+ * @param data - The data used by the parser (see {@link ParserData})
+ * @param obj  - The json object to extract the meta-information from
+ */
+function normalizeLineDirective(data, obj) {
+    parser_1.parseLog.debug('[line-directive]');
+    obj = (0, hooks_1.executeHook)(data.hooks.other.onLineDirective.before, data, obj);
+    const { location, content } = (0, meta_1.retrieveMetaStructure)(data.config, obj);
+    (0, assert_1.guard)(content.startsWith('#line'), 'line directive must start with #line');
+    const match = LineDirectiveRegex.exec(content);
+    let result;
+    if (match === null) {
+        parser_1.parseLog.debug(`[line-directive] does not match the regex ${LineDirectiveRegex.source} given ${JSON.stringify(content)}`);
+        result = {
+            type: "RComment" /* RType.Comment */,
+            location,
+            lexeme: content,
+            info: {
+                fullRange: data.currentRange,
+                additionalTokens: [],
+                fullLexeme: content
+            },
+            content: content.slice(1)
+        };
+    }
+    else {
+        result = {
+            type: "RLineDirective" /* RType.LineDirective */,
+            location,
+            line: parseInt(match[1]),
+            file: match[2],
+            lexeme: content,
+            info: {
+                fullRange: data.currentRange,
+                additionalTokens: [],
+                fullLexeme: content
+            }
+        };
+    }
+    return (0, hooks_1.executeHook)(data.hooks.other.onLineDirective.after, data, result);
+}
+exports.normalizeLineDirective = normalizeLineDirective;
+//# sourceMappingURL=line-directive.js.map