@eagleoutice/flowr 2.7.6 → 2.8.1

package/r-bridge/lang-4.x/ast/model/model.d.ts

@@ -23,7 +23,7 @@ import type { RUnaryOp } from './nodes/r-unary-op';
 import type { RBinaryOp } from './nodes/r-binary-op';
 import type { RPipe } from './nodes/r-pipe';
 import type { RDelimiter } from './nodes/info/r-delimiter';
-/** Simply an empty type constraint used to say that there are additional decorations (see {@link Base}). */
+/** Simply an empty type constraint used to say that there are additional decorations (see {@link RAstNodeBase}). */
 export type NoInfo = object;
 /**
  * Will be used to reconstruct the source of the given element in the R-ast.
@@ -57,27 +57,27 @@ interface Source {
  * @typeParam Info       - can be used to store additional information about the node
  * @typeParam LexemeType - the type of the lexeme, probably always a `string` or `string | undefined`
  */
-export interface Base<Info, LexemeType = string> extends MergeableRecord {
+export interface RAstNodeBase<Info, LexemeType = string> extends MergeableRecord {
     type: RType;
     /** the original string retrieved from R, can be used for further identification */
     lexeme: LexemeType;
     /** allows to attach additional information to the node */
     info: Info & Source;
 }
-export interface WithChildren<Info, Children extends Base<Info, string | undefined>> {
+export interface WithChildren<Info, Children extends RAstNodeBase<Info, string | undefined>> {
     children: readonly Children[];
 }
 /**
  * A helper interface we use to "mark" leaf nodes.
  * <p>
  * Please be aware, that this is not marking from a language perspective,
- * as it is equivalent to the {@link Base} interface.
+ * as it is equivalent to the {@link RAstNodeBase} interface.
  * It is intended to help humans understand the code.
  */
-export interface Leaf<Info = NoInfo, LexemeType = string> extends Base<Info, LexemeType> {
+export interface Leaf<Info = NoInfo, LexemeType = string> extends RAstNodeBase<Info, LexemeType> {
 }
 /**
- * Indicates, that the respective {@link Base} node has known source code
+ * Indicates, that the respective {@link RAstNodeBase} node has known source code
  * location information.
  */
 export interface Location {
@@ -95,7 +95,7 @@ export interface Location {
 export type NamespaceIdentifier = string;
 /**
  * Similar to {@link Location} this is an interface that indicates that
- * the respective {@link Base} node has a respective property (a namespace).
+ * the respective {@link RAstNodeBase} node has a respective property (a namespace).
  */
 export interface Namespace {
     /**

package/r-bridge/lang-4.x/ast/model/nodes/r-access.d.ts

@@ -1,11 +1,11 @@
-import type { Base, Location, NoInfo, RNode } from '../model';
+import type { RAstNodeBase, Location, NoInfo, RNode } from '../model';
 import type { RType } from '../type';
 import type { RArgument, RUnnamedArgument } from './r-argument';
 import type { EmptyArgument } from './r-function-call';
 /**
  * Represents an R Indexing operation with `$`, `@`, `[[`, or `[`.
  */
-interface RAccessBase<Info = NoInfo> extends Base<Info>, Location {
+interface RAccessBase<Info = NoInfo> extends RAstNodeBase<Info>, Location {
     readonly type: RType.Access;
     /** the accessed container/variable/expression */
     accessed: RNode<Info>;

package/r-bridge/lang-4.x/ast/model/nodes/r-argument.d.ts

@@ -1,10 +1,10 @@
-import type { Base, Location, NoInfo, RNode } from '../model';
+import type { RAstNodeBase, Location, NoInfo, RNode } from '../model';
 import type { RType } from '../type';
 import type { RSymbol } from './r-symbol';
 /**
  * Represents a named or unnamed argument of a function definition in R.
  */
-export interface RArgument<Info = NoInfo> extends Base<Info>, Location {
+export interface RArgument<Info = NoInfo> extends RAstNodeBase<Info>, Location {
     readonly type: RType.Argument;
     name: RSymbol<Info> | undefined;
     value: RNode<Info> | undefined;

package/r-bridge/lang-4.x/ast/model/nodes/r-binary-op.d.ts

@@ -1,9 +1,9 @@
-import type { Base, Location, NoInfo, RNode } from '../model';
+import type { RAstNodeBase, Location, NoInfo, RNode } from '../model';
 import type { RType } from '../type';
 /**
  * Operators like `+`, `==`, `&&`, etc.
  */
-export interface RBinaryOp<Info = NoInfo> extends Base<Info>, Location {
+export interface RBinaryOp<Info = NoInfo> extends RAstNodeBase<Info>, Location {
     readonly type: RType.BinaryOp;
     operator: string;
     lhs: RNode<Info>;

package/r-bridge/lang-4.x/ast/model/nodes/r-comment.d.ts

@@ -1,5 +1,5 @@
 import type { Leaf, Location, NoInfo } from '../model';
-import type { RType } from '../type';
+import { RType } from '../type';
 /**
  * ```r
  * # I am a line comment
@@ -7,5 +7,8 @@ import type { RType } from '../type';
  */
 export interface RComment<Info = NoInfo> extends Location, Leaf<Info> {
     readonly type: RType.Comment;
-    content: string;
 }
+/**
+ * Checks whether the given node is an R comment.
+ */
+export declare function isRComment<Info = NoInfo>(node: unknown): node is RComment<Info>;

package/r-bridge/lang-4.x/ast/model/nodes/r-comment.js

@@ -1,3 +1,11 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
+exports.isRComment = isRComment;
+const type_1 = require("../type");
+/**
+ * Checks whether the given node is an R comment.
+ */
+function isRComment(node) {
+    return typeof node === 'object' && node !== null && node.type === type_1.RType.Comment;
+}
 //# sourceMappingURL=r-comment.js.map

package/r-bridge/lang-4.x/ast/model/nodes/r-expression-list.d.ts

@@ -1,11 +1,11 @@
-import type { Base, Location, NoInfo, RNode, WithChildren } from '../model';
+import type { RAstNodeBase, Location, NoInfo, RNode, WithChildren } from '../model';
 import type { RType } from '../type';
 import type { RSymbol } from './r-symbol';
 /**
  * Holds a list of expressions (and hence may be the root of an AST, summarizing all expressions in a file).
  * The `grouping` property holds information on if the expression list is structural or created by a wrapper like `{}` or `()`.
  */
-export interface RExpressionList<Info = NoInfo> extends WithChildren<Info, RNode<Info>>, Base<Info, string | undefined>, Partial<Location> {
+export interface RExpressionList<Info = NoInfo> extends WithChildren<Info, RNode<Info>>, RAstNodeBase<Info, string | undefined>, Partial<Location> {
     readonly type: RType.ExpressionList;
     /** encodes wrappers like `{}` or `()` */
     readonly grouping: undefined | [start: RSymbol<Info>, end: RSymbol<Info>];

package/r-bridge/lang-4.x/ast/model/nodes/r-for-loop.d.ts

@@ -1,4 +1,4 @@
-import type { Base, Location, NoInfo, RNode } from '../model';
+import type { RAstNodeBase, Location, NoInfo, RNode } from '../model';
 import type { RType } from '../type';
 import type { RSymbol } from './r-symbol';
 import type { RExpressionList } from './r-expression-list';
@@ -7,7 +7,7 @@ import type { RExpressionList } from './r-expression-list';
  * for(<variable> in <vector>) <body>
  * ```
  */
-export interface RForLoop<Info = NoInfo> extends Base<Info>, Location {
+export interface RForLoop<Info = NoInfo> extends RAstNodeBase<Info>, Location {
     readonly type: RType.ForLoop;
     /** variable used in for-loop: <p> `for(<variable> in ...) ...`*/
     variable: RSymbol<Info>;

package/r-bridge/lang-4.x/ast/model/nodes/r-function-call.d.ts

@@ -1,4 +1,4 @@
-import type { Base, Location, NoInfo, RNode } from '../model';
+import type { RAstNodeBase, Location, NoInfo, RNode } from '../model';
 import type { RType } from '../type';
 import type { RSymbol } from './r-symbol';
 import type { RArgument } from './r-argument';
@@ -8,7 +8,7 @@ export type RFunctionArgument<Info = NoInfo> = RArgument<Info> | typeof EmptyArg
  * Calls of functions like `a()` and `foo(42, "hello")`.
  * @see RUnnamedFunctionCall
  */
-export interface RNamedFunctionCall<Info = NoInfo> extends Base<Info>, Location {
+export interface RNamedFunctionCall<Info = NoInfo> extends RAstNodeBase<Info>, Location {
     readonly type: RType.FunctionCall;
     readonly named: true;
     functionName: RSymbol<Info>;
@@ -19,7 +19,7 @@ export interface RNamedFunctionCall<Info = NoInfo> extends Base<Info>, Location
  * Direct calls of functions like `(function(x) { x })(3)`.
  * @see RNamedFunctionCall
  */
-export interface RUnnamedFunctionCall<Info = NoInfo> extends Base<Info>, Location {
+export interface RUnnamedFunctionCall<Info = NoInfo> extends RAstNodeBase<Info>, Location {
     readonly type: RType.FunctionCall;
     readonly named: false | undefined;
     calledFunction: RNode<Info>;

package/r-bridge/lang-4.x/ast/model/nodes/r-function-definition.d.ts

@@ -1,4 +1,4 @@
-import type { Base, Location, NoInfo, RNode } from '../model';
+import type { RAstNodeBase, Location, NoInfo, RNode } from '../model';
 import type { RType } from '../type';
 import type { RParameter } from './r-parameter';
 /**
@@ -10,7 +10,7 @@ import type { RParameter } from './r-parameter';
  * \(<parameters>) <body>
  * ```
  */
-export interface RFunctionDefinition<Info = NoInfo> extends Base<Info>, Location {
+export interface RFunctionDefinition<Info = NoInfo> extends RAstNodeBase<Info>, Location {
     readonly type: RType.FunctionDefinition;
     /** the R formals, to our knowledge, they must be unique */
     parameters: RParameter<Info>[];

package/r-bridge/lang-4.x/ast/model/nodes/r-if-then-else.d.ts

@@ -1,4 +1,4 @@
-import type { Base, Location, NoInfo, RNode } from '../model';
+import type { RAstNodeBase, Location, NoInfo, RNode } from '../model';
 import type { RType } from '../type';
 import type { RExpressionList } from './r-expression-list';
 /**
@@ -6,7 +6,7 @@ import type { RExpressionList } from './r-expression-list';
  * if(<condition>) <then> [else <otherwise>]
  * ```
  */
-export interface RIfThenElse<Info = NoInfo> extends Base<Info>, Location {
+export interface RIfThenElse<Info = NoInfo> extends RAstNodeBase<Info>, Location {
     readonly type: RType.IfThenElse;
     condition: RNode<Info>;
     then: RExpressionList<Info>;

package/r-bridge/lang-4.x/ast/model/nodes/r-parameter.d.ts

@@ -1,10 +1,10 @@
-import type { Base, Location, NoInfo, RNode } from '../model';
+import type { RAstNodeBase, Location, NoInfo, RNode } from '../model';
 import type { RType } from '../type';
 import type { RSymbol } from './r-symbol';
 /**
  * Represents a parameter of a function definition in R.
  */
-export interface RParameter<Info = NoInfo> extends Base<Info>, Location {
+export interface RParameter<Info = NoInfo> extends RAstNodeBase<Info>, Location {
     readonly type: RType.Parameter;
     name: RSymbol<Info>;
     /** is it the special ... parameter? */

package/r-bridge/lang-4.x/ast/model/nodes/r-pipe.d.ts

@@ -1,9 +1,9 @@
-import type { Base, Location, NoInfo, RNode } from '../model';
+import type { RAstNodeBase, Location, NoInfo, RNode } from '../model';
 import type { RType } from '../type';
 /**
  * Variant of the binary operator, specifically for the new, built-in pipe operator.
  */
-export interface RPipe<Info = NoInfo> extends Base<Info>, Location {
+export interface RPipe<Info = NoInfo> extends RAstNodeBase<Info>, Location {
     readonly type: RType.Pipe;
     readonly lhs: RNode<Info>;
     readonly rhs: RNode<Info>;

package/r-bridge/lang-4.x/ast/model/nodes/r-repeat-loop.d.ts

@@ -1,4 +1,4 @@
-import type { Base, Location, NoInfo } from '../model';
+import type { RAstNodeBase, Location, NoInfo } from '../model';
 import type { RType } from '../type';
 import type { RExpressionList } from './r-expression-list';
 /**
@@ -6,7 +6,7 @@ import type { RExpressionList } from './r-expression-list';
  * repeat <body>
  * ```
  */
-export interface RRepeatLoop<Info = NoInfo> extends Base<Info>, Location {
+export interface RRepeatLoop<Info = NoInfo> extends RAstNodeBase<Info>, Location {
     readonly type: RType.RepeatLoop;
     body: RExpressionList<Info>;
 }

package/r-bridge/lang-4.x/ast/model/nodes/r-unary-op.d.ts

@@ -1,9 +1,9 @@
-import type { Base, Location, NoInfo, RNode } from '../model';
+import type { RAstNodeBase, Location, NoInfo, RNode } from '../model';
 import type { RType } from '../type';
 /**
  * Unary operations like `+` and `-`
  */
-export interface RUnaryOp<Info = NoInfo> extends Base<Info>, Location {
+export interface RUnaryOp<Info = NoInfo> extends RAstNodeBase<Info>, Location {
     readonly type: RType.UnaryOp;
     operator: string;
     operand: RNode<Info>;

package/r-bridge/lang-4.x/ast/model/nodes/r-while-loop.d.ts

@@ -1,4 +1,4 @@
-import type { Base, Location, NoInfo, RNode } from '../model';
+import type { RAstNodeBase, Location, NoInfo, RNode } from '../model';
 import type { RType } from '../type';
 import type { RExpressionList } from './r-expression-list';
 /**
@@ -6,7 +6,7 @@ import type { RExpressionList } from './r-expression-list';
  * while(<condition>) <body>
  * ```
  */
-export interface RWhileLoop<Info = NoInfo> extends Base<Info>, Location {
+export interface RWhileLoop<Info = NoInfo> extends RAstNodeBase<Info>, Location {
     readonly type: RType.WhileLoop;
     condition: RNode<Info>;
     body: RExpressionList<Info>;

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

@@ -16,7 +16,6 @@ function normalizeComment(data, obj) {
     return {
         type: type_1.RType.Comment,
         location,
-        content: content.slice(1),
         lexeme: content,
         info: {
             fullRange: data.currentRange,

package/r-bridge/lang-4.x/tree-sitter/tree-sitter-normalize.js

@@ -552,7 +552,6 @@ function convertTreeNode(node) {
             return {
                 type: type_1.RType.Comment,
                 location: range,
-                content: node.text.slice(1),
                 lexeme: node.text,
                 ...defaultInfo
             };
@@ -594,7 +593,6 @@ function splitComments(nodes) {
             comments.push([node, {
                     type: type_1.RType.Comment,
                     location: makeSourceRange(node),
-                    content: node.text.slice(1),
                     lexeme: node.text,
                     info: {
                         additionalTokens: [],

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 {};