@eagleoutice/flowr 2.7.5 → 2.8.0

package/r-bridge/roxygen2/roxygen-ast.d.ts

@@ -0,0 +1,218 @@
+import type { SourceLocation } from '../../util/range';
+import type { NodeId } from '../lang-4.x/ast/model/processing/node-id';
+/**
+ * Known Roxygen tags as per {@link https://roxygen2.r-lib.org/reference/index.html}
+ */
+export declare enum KnownRoxygenTags {
+    Aliases = "aliases",
+    Backref = "backref",
+    Concept = "concept",
+    Family = "family",
+    Keywords = "keywords",
+    References = "references",
+    SeeAlso = "seealso",
+    EvalNamespace = "evalNamespace",
+    Export = "export",
+    ExportClass = "exportClass",
+    ExportMethod = "exportMethod",
+    ExportPattern = "exportPattern",
+    ExportS3Method = "exportS3Method",
+    Import = "import",
+    ImportClassesFrom = "importClassesFrom",
+    ImportMethodsFrom = "importMethodsFrom",
+    ImportFrom = "importFrom",
+    RawNamespace = "rawNamespace",
+    UseDynLib = "useDynLib",
+    Md = "md",
+    NoMd = "noMd",
+    Section = "section",
+    Field = "field",
+    Format = "format",
+    Method = "method",
+    Slot = "slot",
+    Source = "source",
+    Description = "description",
+    Details = "details",
+    Example = "example",
+    Examples = "examples",
+    ExamplesIf = "examplesIf",
+    NoRd = "noRd",
+    Param = "param",
+    RawRd = "rawRd",
+    Return = "return",
+    Returns = "returns",
+    Title = "title",
+    Usage = "usage",
+    DescribeIn = "describeIn",
+    Eval = "eval",
+    EvalRd = "evalRd",
+    IncludeRmd = "includeRmd",
+    Inherit = "inherit",
+    InheritDotParams = "inheritDotParams",
+    InheritParams = "inheritParams",
+    InheritSection = "inheritSection",
+    Order = "order",
+    RdName = "rdname",
+    Template = "template",
+    TemplateVar = "templateVar",
+    /** Just plain old text */
+    Text = "text",
+    Name = "name",
+    DocType = "docType",
+    Author = "author",
+    Unknown = "unknown"
+}
+/**
+ * Base interface for all roxygen tags.
+ */
+export interface RoxygenTagBase<Type extends KnownRoxygenTags> {
+    /** The type of the roxygen tag. */
+    type: Type;
+}
+interface RoxygenTagWithValue<Type extends KnownRoxygenTags, Value> extends RoxygenTagBase<Type> {
+    /** The value of the roxygen tag. */
+    value: Value;
+}
+type RoxygenTagFlag<Type extends KnownRoxygenTags> = RoxygenTagBase<Type>;
+export type RoxygenTagAlias = RoxygenTagWithValue<KnownRoxygenTags.Aliases, string[]>;
+export type RoxygenTagBackref = RoxygenTagWithValue<KnownRoxygenTags.Backref, string>;
+export type RoxygenTagConcept = RoxygenTagWithValue<KnownRoxygenTags.Concept, string>;
+export type RoxygenTagFamily = RoxygenTagWithValue<KnownRoxygenTags.Family, string>;
+/** Internal is special in that it causes the topic to be removed from the index */
+export type RoxygenTagKeywords = RoxygenTagWithValue<KnownRoxygenTags.Keywords, (string | 'internal')[]>;
+export type RoxygenTagReferences = RoxygenTagWithValue<KnownRoxygenTags.References, string>;
+export type RoxygenTagSeeAlso = RoxygenTagWithValue<KnownRoxygenTags.SeeAlso, string[]>;
+/** https://roxygen2.r-lib.org/reference/tags-index-crossref.html */
+export type RoxygenCrossrefTag = RoxygenTagAlias | RoxygenTagBackref | RoxygenTagConcept | RoxygenTagFamily | RoxygenTagKeywords | RoxygenTagReferences | RoxygenTagSeeAlso;
+/** Evaluate arbitrary code in the package namespace and insert the results into the NAMESPACE */
+export type RoxygenTagEvalNamespace = RoxygenTagWithValue<KnownRoxygenTags.EvalNamespace, string>;
+export type RoxygenTagExport = RoxygenTagFlag<KnownRoxygenTags.Export>;
+export type RoxygenTagExportClass = RoxygenTagWithValue<KnownRoxygenTags.ExportClass, string>;
+export type RoxygenTagExportMethod = RoxygenTagWithValue<KnownRoxygenTags.ExportMethod, string>;
+export type RoxygenTagExportPattern = RoxygenTagWithValue<KnownRoxygenTags.ExportPattern, string>;
+export type RoxygenTagExportS3Method = RoxygenTagWithValue<KnownRoxygenTags.ExportS3Method, string>;
+export type RoxygenTagImport = RoxygenTagWithValue<KnownRoxygenTags.Import, string>;
+export type RoxygenTagImportClassesFrom = RoxygenTagWithValue<KnownRoxygenTags.ImportClassesFrom, {
+    package: string;
+    classes: string[];
+}>;
+export type RoxygenTagImportMethodsFrom = RoxygenTagWithValue<KnownRoxygenTags.ImportMethodsFrom, {
+    package: string;
+    methods: string[];
+}>;
+export type RoxygenTagImportFrom = RoxygenTagWithValue<KnownRoxygenTags.ImportFrom, {
+    package: string;
+    symbols: string[];
+}>;
+/** Insert literal text directly into the NAMESPACE */
+export type RoxygenTagRawNamespace = RoxygenTagWithValue<KnownRoxygenTags.RawNamespace, string>;
+export type RoxygenTagUseDynLib = RoxygenTagWithValue<KnownRoxygenTags.UseDynLib, string>;
+/** https://roxygen2.r-lib.org/reference/tags-namespace.html */
+export type RoxygenNamespaceTag = RoxygenTagEvalNamespace | RoxygenTagExport | RoxygenTagExportClass | RoxygenTagExportMethod | RoxygenTagExportPattern | RoxygenTagExportS3Method | RoxygenTagImport | RoxygenTagImportClassesFrom | RoxygenTagImportMethodsFrom | RoxygenTagImportFrom | RoxygenTagRawNamespace | RoxygenTagUseDynLib;
+export type RoxygenTagMarkdown = RoxygenTagFlag<KnownRoxygenTags.Md>;
+export type RoxygenTagNoMarkdown = RoxygenTagFlag<KnownRoxygenTags.NoMd>;
+export type RoxygenTagSection = RoxygenTagWithValue<KnownRoxygenTags.Section, {
+    title: string;
+    content: string;
+}>;
+/** https://roxygen2.r-lib.org/reference/tags-rd-formatting.html */
+export type RoxygenFormattingTag = RoxygenTagMarkdown | RoxygenTagNoMarkdown | RoxygenTagSection;
+export type RoxygenTagField = RoxygenTagWithValue<KnownRoxygenTags.Field, {
+    name: string;
+    description: string;
+}>;
+export type RoxygenTagFormat = RoxygenTagWithValue<KnownRoxygenTags.Format, string>;
+export type RoxygenTagMethod = RoxygenTagWithValue<KnownRoxygenTags.Method, {
+    generic: string;
+    class: string;
+}>;
+export type RoxygenTagSlot = RoxygenTagWithValue<KnownRoxygenTags.Slot, {
+    name: string;
+    description: string;
+}>;
+export type RoxygenTagSource = RoxygenTagWithValue<KnownRoxygenTags.Source, string>;
+/** https://roxygen2.r-lib.org/reference/tags-rd-other.html */
+export type RoxygenDatasetDocumentationTag = RoxygenTagField | RoxygenTagFormat | RoxygenTagMethod | RoxygenTagSlot | RoxygenTagSource;
+export type RoxygenTagDescription = RoxygenTagWithValue<KnownRoxygenTags.Description, string>;
+export type RoxygenTagDetails = RoxygenTagWithValue<KnownRoxygenTags.Details, string>;
+/** Embed example from file */
+export type RoxygenTagExample = RoxygenTagWithValue<KnownRoxygenTags.Example, string>;
+export type RoxygenTagExamples = RoxygenTagWithValue<KnownRoxygenTags.Examples, string>;
+export type RoxygenTagExamplesIf = RoxygenTagWithValue<KnownRoxygenTags.ExamplesIf, {
+    condition: string;
+    content: string;
+}>;
+export type RoxygenTagNoRd = RoxygenTagFlag<KnownRoxygenTags.NoRd>;
+export type RoxygenTagParam = RoxygenTagWithValue<KnownRoxygenTags.Param, {
+    name: string;
+    description: string;
+}>;
+/** Insert literal Rd code */
+export type RoxygenTagRawRd = RoxygenTagWithValue<KnownRoxygenTags.RawRd, string>;
+export type RoxygenTagReturn = RoxygenTagWithValue<KnownRoxygenTags.Return | KnownRoxygenTags.Returns, string>;
+export type RoxygenTagTitle = RoxygenTagWithValue<KnownRoxygenTags.Title, string>;
+export type RoxygenTagUsage = RoxygenTagWithValue<KnownRoxygenTags.Usage, string>;
+/** https://roxygen2.r-lib.org/reference/tags-rd.html */
+export type RoxygenFunctionDocumentationTag = RoxygenTagDescription | RoxygenTagDetails | RoxygenTagExample | RoxygenTagExamples | RoxygenTagExamplesIf | RoxygenTagNoRd | RoxygenTagParam | RoxygenTagRawRd | RoxygenTagReturn | RoxygenTagTitle | RoxygenTagUsage;
+export type RoxygenTagDescribeIn = RoxygenTagWithValue<KnownRoxygenTags.DescribeIn, {
+    dest: string;
+    description: string;
+}>;
+/** Evaluate R code and insert the results into the Rd file */
+export type RoxygenTagEval = RoxygenTagWithValue<KnownRoxygenTags.Eval, string>;
+export type RoxygenTagEvalRd = RoxygenTagWithValue<KnownRoxygenTags.EvalRd, string>;
+export type RoxygenTagIncludeRmd = RoxygenTagWithValue<KnownRoxygenTags.IncludeRmd, string>;
+export type RoxygenTagInherit = RoxygenTagWithValue<KnownRoxygenTags.Inherit, {
+    source: string;
+    components: string[];
+}>;
+export type RoxygenTagInheritDotParams = RoxygenTagWithValue<KnownRoxygenTags.InheritDotParams, {
+    source: string;
+    args: string[];
+}>;
+export type RoxygenTagInheritParams = RoxygenTagWithValue<KnownRoxygenTags.InheritParams, string>;
+export type RoxygenTagInheritSection = RoxygenTagWithValue<KnownRoxygenTags.InheritSection, {
+    source: string;
+    section: string;
+}>;
+export type RoxygenTagOrder = RoxygenTagWithValue<KnownRoxygenTags.Order, number | undefined>;
+export type RoxygenTagRdName = RoxygenTagWithValue<KnownRoxygenTags.RdName, string>;
+export type RoxygenTagTemplate = RoxygenTagWithValue<KnownRoxygenTags.Template, string>;
+export type RoxygenTagTemplateVar = RoxygenTagWithValue<KnownRoxygenTags.TemplateVar, {
+    name: string;
+    value: string;
+}>;
+/** https://roxygen2.r-lib.org/reference/tags-reuse.html */
+export type RoxygenReusingDocumentationTag = RoxygenTagDescribeIn | RoxygenTagEval | RoxygenTagEvalRd | RoxygenTagIncludeRmd | RoxygenTagInherit | RoxygenTagInheritDotParams | RoxygenTagInheritParams | RoxygenTagInheritSection | RoxygenTagOrder | RoxygenTagRdName | RoxygenTagTemplate | RoxygenTagTemplateVar;
+export type RoxygenUnknownTag = RoxygenTagWithValue<KnownRoxygenTags.Unknown, {
+    tag: string;
+    content: string;
+}>;
+export type RoxygenTagAuthor = RoxygenTagWithValue<KnownRoxygenTags.Author, string>;
+export type RoxygenDocType = RoxygenTagWithValue<KnownRoxygenTags.DocType, string>;
+export type RoxygenTagName = RoxygenTagWithValue<KnownRoxygenTags.Name, string>;
+export type RoxygenTagText = RoxygenTagWithValue<KnownRoxygenTags.Text, string>;
+export type RoxygenOtherTag = RoxygenTagAuthor | RoxygenUnknownTag | RoxygenDocType | RoxygenTagName | RoxygenTagText;
+/**
+ * All known Roxygen tag types.
+ */
+export type RoxygenTag = RoxygenCrossrefTag | RoxygenNamespaceTag | RoxygenFormattingTag | RoxygenDatasetDocumentationTag | RoxygenFunctionDocumentationTag | RoxygenReusingDocumentationTag | RoxygenOtherTag;
+/**
+ * A roxygen comment block, consisting of multiple {@link RoxygenTag|roxygen tags}.
+ */
+export interface RoxygenBlock {
+    readonly type: 'roxygen-block';
+    /** The ast node to which we assign the comment */
+    readonly requestNode: NodeId;
+    /** The AST node ID of the R node this roxygen block is attached to, if any (this comment may be a parent of the requested) */
+    readonly attachedTo?: NodeId;
+    /** The source location of the entire roxygen block, if available. */
+    readonly range?: SourceLocation;
+    /** The roxygen tags contained in this block. */
+    readonly tags: readonly RoxygenTag[];
+}
+/**
+ * Checks whether the given text is a known roxygen tag.
+ */
+export declare function isKnownRoxygenText(text: string): text is KnownRoxygenTags;
+export {};

package/r-bridge/roxygen2/roxygen-ast.js

@@ -0,0 +1,82 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.KnownRoxygenTags = void 0;
+exports.isKnownRoxygenText = isKnownRoxygenText;
+/**
+ * Known Roxygen tags as per {@link https://roxygen2.r-lib.org/reference/index.html}
+ */
+var KnownRoxygenTags;
+(function (KnownRoxygenTags) {
+    /* ---- Tags Index Crossref ---- */
+    KnownRoxygenTags["Aliases"] = "aliases";
+    KnownRoxygenTags["Backref"] = "backref";
+    KnownRoxygenTags["Concept"] = "concept";
+    KnownRoxygenTags["Family"] = "family";
+    KnownRoxygenTags["Keywords"] = "keywords";
+    KnownRoxygenTags["References"] = "references";
+    KnownRoxygenTags["SeeAlso"] = "seealso";
+    /* ---- Tags Namespace ---- */
+    KnownRoxygenTags["EvalNamespace"] = "evalNamespace";
+    KnownRoxygenTags["Export"] = "export";
+    KnownRoxygenTags["ExportClass"] = "exportClass";
+    KnownRoxygenTags["ExportMethod"] = "exportMethod";
+    KnownRoxygenTags["ExportPattern"] = "exportPattern";
+    KnownRoxygenTags["ExportS3Method"] = "exportS3Method";
+    KnownRoxygenTags["Import"] = "import";
+    KnownRoxygenTags["ImportClassesFrom"] = "importClassesFrom";
+    KnownRoxygenTags["ImportMethodsFrom"] = "importMethodsFrom";
+    KnownRoxygenTags["ImportFrom"] = "importFrom";
+    KnownRoxygenTags["RawNamespace"] = "rawNamespace";
+    KnownRoxygenTags["UseDynLib"] = "useDynLib";
+    /* ---- Tags related to Markdown formatting ---- */
+    KnownRoxygenTags["Md"] = "md";
+    KnownRoxygenTags["NoMd"] = "noMd";
+    KnownRoxygenTags["Section"] = "section";
+    /* ---- Documenting Datasets and Classes ---- */
+    KnownRoxygenTags["Field"] = "field";
+    KnownRoxygenTags["Format"] = "format";
+    KnownRoxygenTags["Method"] = "method";
+    KnownRoxygenTags["Slot"] = "slot";
+    KnownRoxygenTags["Source"] = "source";
+    /* ---- Documenting Functions ---- */
+    KnownRoxygenTags["Description"] = "description";
+    KnownRoxygenTags["Details"] = "details";
+    KnownRoxygenTags["Example"] = "example";
+    KnownRoxygenTags["Examples"] = "examples";
+    KnownRoxygenTags["ExamplesIf"] = "examplesIf";
+    KnownRoxygenTags["NoRd"] = "noRd";
+    KnownRoxygenTags["Param"] = "param";
+    KnownRoxygenTags["RawRd"] = "rawRd";
+    KnownRoxygenTags["Return"] = "return";
+    KnownRoxygenTags["Returns"] = "returns";
+    KnownRoxygenTags["Title"] = "title";
+    KnownRoxygenTags["Usage"] = "usage";
+    /* ---- Reusing Documentation ---- */
+    KnownRoxygenTags["DescribeIn"] = "describeIn";
+    KnownRoxygenTags["Eval"] = "eval";
+    KnownRoxygenTags["EvalRd"] = "evalRd";
+    KnownRoxygenTags["IncludeRmd"] = "includeRmd";
+    KnownRoxygenTags["Inherit"] = "inherit";
+    KnownRoxygenTags["InheritDotParams"] = "inheritDotParams";
+    KnownRoxygenTags["InheritParams"] = "inheritParams";
+    KnownRoxygenTags["InheritSection"] = "inheritSection";
+    KnownRoxygenTags["Order"] = "order";
+    KnownRoxygenTags["RdName"] = "rdname";
+    KnownRoxygenTags["Template"] = "template";
+    KnownRoxygenTags["TemplateVar"] = "templateVar";
+    /* ---- Other, not part of the references above ---- */
+    /** Just plain old text */
+    KnownRoxygenTags["Text"] = "text";
+    KnownRoxygenTags["Name"] = "name";
+    KnownRoxygenTags["DocType"] = "docType";
+    KnownRoxygenTags["Author"] = "author";
+    KnownRoxygenTags["Unknown"] = "unknown";
+})(KnownRoxygenTags || (exports.KnownRoxygenTags = KnownRoxygenTags = {}));
+const ValidRoxygenTagsSet = new Set(Object.values(KnownRoxygenTags));
+/**
+ * Checks whether the given text is a known roxygen tag.
+ */
+function isKnownRoxygenText(text) {
+    return ValidRoxygenTagsSet.has(text);
+}
+//# sourceMappingURL=roxygen-ast.js.map

package/r-bridge/roxygen2/roxygen-parse.d.ts

@@ -0,0 +1,24 @@
+import type { RoxygenBlock, RoxygenTag } from './roxygen-ast';
+import type { RNode } from '../lang-4.x/ast/model/model';
+import type { AstIdMap, ParentInformation } from '../lang-4.x/ast/model/processing/decorate';
+/**
+ * Parses the roxygen comments attached to a node into a RoxygenBlock AST node.
+ * Will return `undefined` if there are no valid roxygen comments attached to the node.
+ * @param node  - The node to parse the roxygen comments for
+ * @param idMap - An optional id map to traverse up the AST to find comments attached to parent nodes
+ */
+export declare function parseRoxygenCommentsOfNode(node: RNode<ParentInformation>, idMap?: AstIdMap): RoxygenBlock | undefined;
+interface RoxygenParseContext {
+    lines: string[];
+    tags: RoxygenTag[];
+    idx: number;
+}
+type TagLine = [tag: string, remTagLine?: string];
+/**
+ * Parses a roxygen comment into a RoxygenBlock AST node.
+ * Will return an empty array if the comment has no valid roxygen comment.
+ * @see {@link parseRoxygenCommentsOfNode} - to parse comments attached to a node
+ */
+export declare function parseRoxygenComment(commentText: readonly string[]): RoxygenTag[];
+export declare const firstAndRest: (firstName: string, secondName: string) => (s: RoxygenParseContext, t: TagLine) => void;
+export {};

package/r-bridge/roxygen2/roxygen-parse.js

@@ -0,0 +1,214 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.firstAndRest = void 0;
+exports.parseRoxygenCommentsOfNode = parseRoxygenCommentsOfNode;
+exports.parseRoxygenComment = parseRoxygenComment;
+const roxygen_ast_1 = require("./roxygen-ast");
+const r_comment_1 = require("../lang-4.x/ast/model/nodes/r-comment");
+const assert_1 = require("../../util/assert");
+const args_1 = require("../../util/text/args");
+const range_1 = require("../../util/range");
+function prepareCommentContext(commentText) {
+    const contents = [];
+    for (const line of commentText) {
+        const trimmed = line.trim();
+        if (trimmed.length === 0) {
+            continue;
+        }
+        else if (!trimmed.startsWith('#')) {
+            // we are done with the roxygen comment
+            break;
+        }
+        contents.push((trimmed.startsWith('#\'') ? trimmed.slice(2) : trimmed.slice(1)).trimEnd());
+    }
+    return contents;
+}
+/**
+ * Parses the roxygen comments attached to a node into a RoxygenBlock AST node.
+ * Will return `undefined` if there are no valid roxygen comments attached to the node.
+ * @param node  - The node to parse the roxygen comments for
+ * @param idMap - An optional id map to traverse up the AST to find comments attached to parent nodes
+ */
+function parseRoxygenCommentsOfNode(node, idMap) {
+    let comments;
+    let cur = node;
+    do {
+        comments = cur?.info.additionalTokens
+            ?.filter(r_comment_1.isRComment).filter(r => (0, assert_1.isNotUndefined)(r.lexeme));
+        cur = cur?.info.parent ? idMap?.get(cur.info.parent) : undefined;
+    } while ((comments === undefined || comments.length === 0) && cur !== undefined);
+    if (comments === undefined || comments.length === 0) {
+        return undefined;
+    }
+    const commentContent = comments.map(c => c.lexeme);
+    return {
+        type: 'roxygen-block',
+        tags: parseRoxygenComment(commentContent),
+        attachedTo: cur?.info.id,
+        requestNode: node.info.id,
+        range: [
+            ...(0, range_1.mergeRanges)(...comments.map(c => c.location)),
+            comments.find(c => c.info.file)?.info.file
+        ]
+    };
+}
+/**
+ * Parses a roxygen comment into a RoxygenBlock AST node.
+ * Will return an empty array if the comment has no valid roxygen comment.
+ * @see {@link parseRoxygenCommentsOfNode} - to parse comments attached to a node
+ */
+function parseRoxygenComment(commentText) {
+    const contents = prepareCommentContext(commentText);
+    const state = {
+        lines: contents,
+        tags: [],
+        idx: 0
+    };
+    val(state, [roxygen_ast_1.KnownRoxygenTags.Text]);
+    return state.tags;
+}
+function atEnd(state) {
+    return state.idx >= state.lines.length;
+}
+function atTag(state) {
+    if (atEnd(state)) {
+        return undefined;
+    }
+    const line = state.lines[state.idx].trim();
+    if (!line.startsWith('@')) {
+        return undefined;
+    }
+    const firstSpace = line.indexOf(' ');
+    return firstSpace === -1 ? [line.slice(1), undefined] : [line.slice(1, firstSpace), line.slice(firstSpace + 1).trim()];
+}
+function advanceLine(state) {
+    return state.lines[state.idx++];
+}
+function collectUntilNextTag(state) {
+    const collected = [];
+    while (!atEnd(state)) {
+        const mayTag = atTag(state);
+        if (mayTag) {
+            advanceLine(state);
+            return [collected, mayTag];
+        }
+        collected.push(advanceLine(state));
+    }
+    return [collected, undefined];
+}
+function addTag(state, tag) {
+    state.tags.push(tag);
+}
+function val(state, tagName, lineToVal = l => l.join('\n').trim()) {
+    const [lines, nextTag] = collectUntilNextTag(state);
+    if (tagName[1]) {
+        lines.unshift(tagName[1]);
+    }
+    if (tagName[0] !== roxygen_ast_1.KnownRoxygenTags.Text || lines.length > 0) {
+        const n = tagName[0];
+        if ((0, roxygen_ast_1.isKnownRoxygenText)(n)) {
+            const val = lineToVal(lines);
+            addTag(state, (val !== undefined ? {
+                type: n,
+                value: val
+            } : { type: n }));
+        }
+        else {
+            addTag(state, {
+                type: roxygen_ast_1.KnownRoxygenTags.Unknown,
+                value: {
+                    tag: n,
+                    content: lines.join(' ')
+                }
+            });
+        }
+    }
+    parseRoxygenTag(state, nextTag);
+}
+const spaceVals = (s, t) => val(s, t, l => (0, args_1.splitAtEscapeSensitive)(l.join(' ')));
+const flagVal = (s, t) => val(s, t, () => undefined);
+const section = (s, t) => val(s, t, l => {
+    return { title: l[0].trim(), content: l.slice(1).join('\n').trim() };
+});
+const firstAndRest = (firstName, secondName) => (s, t) => val(s, t, l => {
+    const vals = (0, args_1.splitAtEscapeSensitive)(l.join('\n'));
+    return { [firstName]: vals[0], [secondName]: vals.slice(1).join(' ').trim() };
+});
+exports.firstAndRest = firstAndRest;
+const firstAndArrayRest = (firstName, secondName) => (s, t) => val(s, t, l => {
+    const vals = (0, args_1.splitAtEscapeSensitive)(l.join('\n'));
+    return { [firstName]: vals[0], [secondName]: vals.slice(1) };
+});
+const asNumber = (s, t) => val(s, t, l => {
+    const num = Number(l.join(' ').trim());
+    return Number.isNaN(num) ? undefined : num;
+});
+const TagMap = {
+    [roxygen_ast_1.KnownRoxygenTags.Aliases]: spaceVals,
+    [roxygen_ast_1.KnownRoxygenTags.Backref]: val,
+    [roxygen_ast_1.KnownRoxygenTags.Concept]: val,
+    [roxygen_ast_1.KnownRoxygenTags.Family]: val,
+    [roxygen_ast_1.KnownRoxygenTags.Keywords]: spaceVals,
+    [roxygen_ast_1.KnownRoxygenTags.References]: val,
+    [roxygen_ast_1.KnownRoxygenTags.SeeAlso]: spaceVals,
+    [roxygen_ast_1.KnownRoxygenTags.EvalNamespace]: val,
+    [roxygen_ast_1.KnownRoxygenTags.Export]: flagVal,
+    [roxygen_ast_1.KnownRoxygenTags.ExportClass]: val,
+    [roxygen_ast_1.KnownRoxygenTags.ExportMethod]: val,
+    [roxygen_ast_1.KnownRoxygenTags.ExportPattern]: val,
+    [roxygen_ast_1.KnownRoxygenTags.ExportS3Method]: val,
+    [roxygen_ast_1.KnownRoxygenTags.Import]: val,
+    [roxygen_ast_1.KnownRoxygenTags.ImportClassesFrom]: firstAndArrayRest('package', 'classes'),
+    [roxygen_ast_1.KnownRoxygenTags.ImportMethodsFrom]: firstAndArrayRest('package', 'methods'),
+    [roxygen_ast_1.KnownRoxygenTags.ImportFrom]: firstAndArrayRest('package', 'symbols'),
+    [roxygen_ast_1.KnownRoxygenTags.RawNamespace]: val,
+    [roxygen_ast_1.KnownRoxygenTags.UseDynLib]: val,
+    [roxygen_ast_1.KnownRoxygenTags.Md]: flagVal,
+    [roxygen_ast_1.KnownRoxygenTags.NoMd]: flagVal,
+    [roxygen_ast_1.KnownRoxygenTags.Section]: section,
+    [roxygen_ast_1.KnownRoxygenTags.Field]: (0, exports.firstAndRest)('name', 'description'),
+    [roxygen_ast_1.KnownRoxygenTags.Format]: val,
+    [roxygen_ast_1.KnownRoxygenTags.Method]: (0, exports.firstAndRest)('generic', 'class'),
+    [roxygen_ast_1.KnownRoxygenTags.Slot]: (0, exports.firstAndRest)('name', 'description'),
+    [roxygen_ast_1.KnownRoxygenTags.Source]: val,
+    [roxygen_ast_1.KnownRoxygenTags.Description]: val,
+    [roxygen_ast_1.KnownRoxygenTags.Details]: val,
+    [roxygen_ast_1.KnownRoxygenTags.Example]: val,
+    [roxygen_ast_1.KnownRoxygenTags.Examples]: val,
+    [roxygen_ast_1.KnownRoxygenTags.ExamplesIf]: (0, exports.firstAndRest)('condition', 'content'),
+    [roxygen_ast_1.KnownRoxygenTags.NoRd]: flagVal,
+    [roxygen_ast_1.KnownRoxygenTags.Param]: (0, exports.firstAndRest)('name', 'description'),
+    [roxygen_ast_1.KnownRoxygenTags.RawRd]: val,
+    [roxygen_ast_1.KnownRoxygenTags.Return]: val,
+    [roxygen_ast_1.KnownRoxygenTags.Returns]: val,
+    [roxygen_ast_1.KnownRoxygenTags.Title]: val,
+    [roxygen_ast_1.KnownRoxygenTags.Usage]: val,
+    [roxygen_ast_1.KnownRoxygenTags.DescribeIn]: (0, exports.firstAndRest)('dest', 'description'),
+    [roxygen_ast_1.KnownRoxygenTags.Eval]: val,
+    [roxygen_ast_1.KnownRoxygenTags.EvalRd]: val,
+    [roxygen_ast_1.KnownRoxygenTags.IncludeRmd]: val,
+    [roxygen_ast_1.KnownRoxygenTags.Inherit]: firstAndArrayRest('source', 'components'),
+    [roxygen_ast_1.KnownRoxygenTags.InheritDotParams]: firstAndArrayRest('source', 'args'),
+    [roxygen_ast_1.KnownRoxygenTags.InheritParams]: val,
+    [roxygen_ast_1.KnownRoxygenTags.InheritSection]: (0, exports.firstAndRest)('source', 'section'),
+    [roxygen_ast_1.KnownRoxygenTags.Order]: asNumber,
+    [roxygen_ast_1.KnownRoxygenTags.RdName]: val,
+    [roxygen_ast_1.KnownRoxygenTags.Template]: val,
+    [roxygen_ast_1.KnownRoxygenTags.TemplateVar]: (0, exports.firstAndRest)('name', 'value'),
+    [roxygen_ast_1.KnownRoxygenTags.Text]: val,
+    [roxygen_ast_1.KnownRoxygenTags.Name]: val,
+    [roxygen_ast_1.KnownRoxygenTags.DocType]: val,
+    [roxygen_ast_1.KnownRoxygenTags.Author]: val,
+    [roxygen_ast_1.KnownRoxygenTags.Unknown]: (s, t) => val(s, t, l => ({
+        tag: t[0],
+        content: l.join(' ')
+    }))
+};
+function parseRoxygenTag(state, tagName) {
+    if (tagName === undefined) {
+        return;
+    }
+    const parser = TagMap[tagName[0]] ?? val;
+    parser(state, tagName);
+}
+//# sourceMappingURL=roxygen-parse.js.map

package/reconstruct/auto-select/magic-comments.js

@@ -31,7 +31,7 @@ const magicCommentIdMapper = {
         return ret;
     }
 };
-const commentTriggerRegex = / flowr@(\w+)/;
+const commentTriggerRegex = /# flowr@(\w+)/;
 /**
  * This takes an {@link NormalizedAst} and returns an auto-select predicate for {@link reconstructToCode},
  * which will automatically include lines marked by these special comments!
@@ -58,11 +58,11 @@ function makeMagicCommentHandler(and) {
                     return;
                 }
                 for (const c of comments) {
-                    if (c.type !== type_1.RType.Comment || !c.content.startsWith(' flowr@')) {
+                    if (c.type !== type_1.RType.Comment || !c.lexeme.startsWith('# flowr@')) {
                         continue;
                     }
-                    const match = commentTriggerRegex.exec(c.content);
-                    (0, assert_1.guard)(match !== null, `invalid magic comment: ${c.content}`);
+                    const match = commentTriggerRegex.exec(c.lexeme);
+                    (0, assert_1.guard)(match !== null, `invalid magic comment: ${c.lexeme}`);
                     const idMapper = magicCommentIdMapper[match[1]];
                     (0, assert_1.guard)(idMapper !== undefined, `unknown magic comment: ${match[1]}`);
                     const ls = idMapper(c, startLineStack);

package/slicing/static/slice-call.js

@@ -33,7 +33,7 @@ function getAllFunctionCallTargets(dataflowGraph, callerInfo, baseEnvironment, q
     const functionCallTargets = queue.memoizeCallTargets(functionCallDefs.join(';'), () => (0, linker_1.getAllLinkedFunctionDefinitions)(new Set(functionCallDefs), dataflowGraph)[0]);
     return [functionCallTargets, activeEnvironment];
 }
-function includeArgumentFunctionCallClosure(arg, baseEnvironment, activeEnvironment, queue, dataflowGraph) {
+function includeArgumentFunctionCallClosure(arg, activeEnvironment, queue, dataflowGraph) {
     const valueRoot = (0, graph_1.getReferenceOfArgument)(arg);
     if (!valueRoot) {
         return;
@@ -44,7 +44,7 @@ function includeArgumentFunctionCallClosure(arg, baseEnvironment, activeEnvironm
 function linkCallTargets(onlyForSideEffects, functionCallTargets, activeEnvironment, activeEnvironmentFingerprint, queue) {
     for (const functionCallTarget of functionCallTargets) {
         for (const exitPoint of functionCallTarget.exitPoints) {
-            queue.add(exitPoint, activeEnvironment, activeEnvironmentFingerprint, onlyForSideEffects);
+            queue.add(exitPoint.nodeId, activeEnvironment, activeEnvironmentFingerprint, onlyForSideEffects);
         }
         // handle open reads
         for (const openIn of functionCallTarget.subflow.in) {
@@ -60,7 +60,6 @@ function linkCallTargets(onlyForSideEffects, functionCallTargets, activeEnvironm
 }
 /** returns the new threshold hit count */
 function sliceForCall(current, callerInfo, dataflowInformation, queue, ctx) {
-    const baseEnvironment = current.baseEnvironment;
     const [functionCallTargets, activeEnvironment] = getAllFunctionCallTargets(dataflowInformation.graph, callerInfo, current.baseEnvironment, queue, ctx);
     const activeEnvironmentFingerprint = (0, fingerprint_1.envFingerprint)(activeEnvironment);
     if (functionCallTargets.size === 0) {
@@ -69,7 +68,7 @@ function sliceForCall(current, callerInfo, dataflowInformation, queue, ctx) {
          * hence, we add a new flag and add all argument values to the queue causing directly
          */
         for (const arg of callerInfo.args) {
-            includeArgumentFunctionCallClosure(arg, baseEnvironment, activeEnvironment, queue, dataflowInformation.graph);
+            includeArgumentFunctionCallClosure(arg, activeEnvironment, queue, dataflowInformation.graph);
         }
         return;
     }

package/slicing/static/static-slicer.js

@@ -66,9 +66,9 @@ function staticSlice(ctx, info, { idMap }, criteria, direction, threshold = 75,
         }
         const [currentVertex, currentEdges] = currentInfo;
         // we only add control dependencies iff 1) we are in different function call or 2) they have, at least, the same nesting as the slicing seed
-        if (currentVertex.cds && currentVertex.cds.length > 0) {
+        if (currentVertex.controlDependencies && currentVertex.controlDependencies.length > 0) {
             const topLevel = graph.isRoot(id) || sliceSeedIds.has(id);
-            for (const cd of currentVertex.cds.filter(({ id }) => !queue.hasId(id))) {
+            for (const cd of currentVertex.controlDependencies.filter(({ id }) => !queue.hasId(id))) {
                 if (!topLevel || (idMap.get(cd.id)?.info.nesting ?? 0) >= minNesting) {
                     queue.add(cd.id, baseEnvironment, baseEnvFingerprint, false);
                 }

package/statistics/features/supported/defined-functions/defined-functions.js

@@ -57,7 +57,7 @@ function visitDefinitions(info, input) {
         }
         const [fnDefinition] = dfNode;
         (0, assert_1.guard)(fnDefinition.tag === vertex_1.VertexType.FunctionDefinition, () => `Dataflow node is not a function definition (${JSON.stringify(fnDefinition)}))})`);
-        const returnTypes = fnDefinition.exitPoints.map(ep => graph.get(ep, true)).filter(assert_1.isNotUndefined)
+        const returnTypes = fnDefinition.exitPoints.map(ep => graph.get(ep.nodeId, true)).filter(assert_1.isNotUndefined)
             .map(([vertex]) => {
             const l = graph.idMap?.get(vertex.id)?.location;
             return {

package/util/collections/defaultmap.d.ts

@@ -25,10 +25,10 @@ export declare class DefaultMap<K, V = K> {
     /**
      * Iterates over all entries that have been set (explicitly or by the generator)
      */
-    entries(): IterableIterator<[K, V]>;
+    entries(): MapIterator<[K, V]>;
     /** returns only the keys really stored in the map */
-    keys(): IterableIterator<K>;
-    values(): IterableIterator<V>;
+    keys(): MapIterator<K>;
+    values(): MapIterator<V>;
     delete(k: K): boolean;
     size(): number;
 }