@eagleoutice/flowr 1.5.1 → 2.0.0

package/r-bridge/data/data.d.ts

@@ -0,0 +1,603 @@
+export declare const flowrCapabilities: {
+    readonly name: "Capabilities of flowR";
+    readonly description: "This is an evolving representation of what started with #636 to formulate capabilities in a structured format.";
+    readonly version: "0.0.1";
+    readonly capabilities: readonly [{
+        readonly name: "Names and Identifiers";
+        readonly id: "names-and-identifiers";
+        readonly capabilities: readonly [{
+            readonly name: "Form";
+            readonly id: "form";
+            readonly capabilities: readonly [{
+                readonly name: "Normal";
+                readonly id: "name-normal";
+                readonly supported: "fully";
+                readonly description: "_Recognize constructs like `a`, `plot`, ..._";
+            }, {
+                readonly name: "Quoted";
+                readonly id: "name-quoted";
+                readonly supported: "fully";
+                readonly description: "_Recognize `\"a\"`, `'plot'`, ..._";
+            }, {
+                readonly name: "Escaped";
+                readonly id: "name-escaped";
+                readonly supported: "fully";
+                readonly description: "_Recognize `` `a` ``, `` `plot` ``, ..._";
+            }];
+        }, {
+            readonly name: "Resolution";
+            readonly id: "resolution";
+            readonly capabilities: readonly [{
+                readonly name: "Global Scope";
+                readonly id: "global-scope";
+                readonly supported: "fully";
+                readonly description: "_For example, tracking a big table of current identifier bindings_";
+            }, {
+                readonly name: "Lexicographic Scope";
+                readonly id: "lexicographic-scope";
+                readonly supported: "fully";
+                readonly description: "_For example, support function definition scopes_";
+            }, {
+                readonly name: "Closures";
+                readonly id: "closures";
+                readonly supported: "partially";
+                readonly description: "_Handling [function factories](https://adv-r.hadley.nz/function-factories.html) and friends._ Currently, we do not have enough tests to be sure.";
+            }, {
+                readonly name: "Dynamic Environment Resolution";
+                readonly id: "dynamic-environment-resolution";
+                readonly supported: "not";
+                readonly description: "_For example, using `new.env` and friends_";
+            }, {
+                readonly name: "Environment Sharing";
+                readonly id: "environment-sharing";
+                readonly supported: "not";
+                readonly description: "_Handling side-effects by environments which are not copied when modified_";
+            }, {
+                readonly name: "Search Path";
+                readonly id: "search-path";
+                readonly supported: "not";
+                readonly description: "_Handling [R's search path](https://cran.r-project.org/doc/manuals/r-release/R-lang.html#Search-path) as explained in [Advanced R](https://adv-r.hadley.nz/environments.html#search-path)._ Currently, _flowR_ does not support dynamic modifications with `attach`, `search`, or `fn_env` and tests are definitely missing. Yet, theoretically, the tooling is all there.";
+            }, {
+                readonly name: "Namespaces";
+                readonly id: "namespaces";
+                readonly supported: "not";
+                readonly description: "_Handling R's namespaces as explained in [Advanced R](https://adv-r.hadley.nz/environments.html#namespaces)_";
+            }, {
+                readonly name: "Accessing Exported Names";
+                readonly id: "accessing-exported-names";
+                readonly supported: "partially";
+                readonly description: "_Resolving calls with `::` to their origin._ Accessing external files is allowed, although the name of packages etc. is not resolved correctly.";
+            }, {
+                readonly name: "Accessing Internal Names";
+                readonly id: "accessing-internal-names";
+                readonly supported: "not";
+                readonly description: "_Similar to `::` but for internal names._";
+            }, {
+                readonly name: "Library Loading";
+                readonly id: "library-loading";
+                readonly supported: "not";
+                readonly description: "_Resolve libraries identified with `library`, `require`, `attachNamespace`, ... and attach them to the search path_";
+            }];
+        }];
+    }, {
+        readonly name: "Expressions";
+        readonly id: "expressions";
+        readonly capabilities: readonly [{
+            readonly name: "Function Calls";
+            readonly id: "function-calls";
+            readonly capabilities: readonly [{
+                readonly name: "Grouping";
+                readonly id: "grouping";
+                readonly supported: "fully";
+                readonly description: "_Recognize groups done with `(`, `{`, ... (more precisely, their default mapping to the primitive implementations)._";
+            }, {
+                readonly name: "Normal Call";
+                readonly id: "call-normal";
+                readonly supported: "fully";
+                readonly description: "_Recognize and resolve calls like `f(x)`, `foo::bar(x, y)`, ..._";
+                readonly capabilities: readonly [{
+                    readonly name: "Unnamed Arguments";
+                    readonly id: "unnamed-arguments";
+                    readonly supported: "fully";
+                    readonly description: "_Recognize and resolve calls like `f(3)`, `foo::bar(3, c(1,2))`, ..._";
+                }, {
+                    readonly name: "Empty Arguments";
+                    readonly id: "empty-arguments";
+                    readonly supported: "fully";
+                    readonly description: "_Essentially a special form of an unnamed argument as in `foo::bar(3, ,42)`, ..._";
+                }, {
+                    readonly name: "Named Arguments";
+                    readonly id: "named-arguments";
+                    readonly supported: "fully";
+                    readonly description: "_Recognize and resolve calls like `f(x = 3)`, `foo::bar(x = 3, y = 4)`, ..._";
+                }, {
+                    readonly name: "String Arguments";
+                    readonly id: "string-arguments";
+                    readonly supported: "fully";
+                    readonly description: "_Recognize and resolve calls like `f('x' = 3)`, `foo::bar('x' = 3, \"y\" = 4)`, ..._";
+                }, {
+                    readonly name: "Resolve Arguments";
+                    readonly id: "resolve-arguments";
+                    readonly supported: "partially";
+                    readonly description: "_Correctly bind arguments (including [`pmatch`](https://www.rdocumentation.org/packages/base/versions/3.6.2/topics/pmatch))._ Currently, we do not have a correct implementation for `pmatch`. Furthermore, more tests would be nice.";
+                }, {
+                    readonly name: "Side-Effects in Argument";
+                    readonly id: "side-effects-in-argument";
+                    readonly supported: "partially";
+                    readonly description: "_Handle side-effects of arguments (e.g., `f(x <- 3)`, `f(x = y <- 3)`, ...)._ We have not enough tests to be sure";
+                }, {
+                    readonly name: "Side-Effects in Function Call";
+                    readonly id: "side-effects-in-function-call";
+                    readonly supported: "partially";
+                    readonly description: "_Handle side-effects of function calls (e.g., `setXTo(3)`, ...) for example achieved with the super assignment._ We need more tests and handlings. Furthermore, we do not detect side effects with external files, network, logging, etc.";
+                }];
+            }, {
+                readonly name: "Anonymous Calls";
+                readonly id: "call-anonymous";
+                readonly supported: "fully";
+                readonly description: "_Recognize and resolve calls like `(function(x) x)(3)`, `factory(0)()`, ..._";
+            }, {
+                readonly name: "Infix Calls";
+                readonly id: "infix-calls";
+                readonly supported: "fully";
+                readonly description: "_Recognize and resolve calls like `x + y`, `x %>% f(y)`, ..._";
+            }, {
+                readonly name: "Redefinition of Built-In Functions/primitives";
+                readonly id: "redefinition-of-built-in-functions-primitives";
+                readonly supported: "partially";
+                readonly description: "_Handle cases like `print <- function(x) x`, `` `for` <- function(a,b,c) a``, ..._ Currently, we can not handle all of them there are no tests. Still wip as part of desugaring";
+            }, {
+                readonly name: "Index Access";
+                readonly id: "index-access";
+                readonly capabilities: readonly [{
+                    readonly name: "Single Bracket Access";
+                    readonly id: "single-bracket-access";
+                    readonly supported: "fully";
+                    readonly description: "_Detect calls like `x[i]`, `x[i, ,b]`, `x[3][y]`, ... This does not include the real separation of cells, which is handled extra._";
+                }, {
+                    readonly name: "Double Bracket Access";
+                    readonly id: "double-bracket-access";
+                    readonly supported: "fully";
+                    readonly description: "_Detect calls like `x[[i]]`, `x[[i, b]]`, ... Similar to single bracket._";
+                }, {
+                    readonly name: "Dollar Access";
+                    readonly id: "dollar-access";
+                    readonly supported: "fully";
+                    readonly description: "_Detect calls like `x$y`, `x$\"y\"`, `x$y$z`, ..._";
+                }, {
+                    readonly name: "Slot Access";
+                    readonly id: "slot-access";
+                    readonly supported: "fully";
+                    readonly description: "_Detect calls like `x@y`, `x@y@z`, ..._";
+                }, {
+                    readonly name: "Access with Argument-Names";
+                    readonly id: "access-with-argument-names";
+                    readonly supported: "fully";
+                    readonly description: "_Detect calls like `x[i = 3]`, `x[[i=]]`, ..._";
+                }, {
+                    readonly name: "Access with Empty";
+                    readonly id: "access-with-empty";
+                    readonly supported: "fully";
+                    readonly description: "_Detect calls like `x[]`, `x[2,,42]`, ..._";
+                }, {
+                    readonly name: "Subsetting";
+                    readonly id: "subsetting";
+                    readonly supported: "fully";
+                    readonly description: "_Detect calls like `x[i > 3]`, `x[c(1,3)]`, ..._";
+                }];
+            }, {
+                readonly name: "Operators";
+                readonly id: "operators";
+                readonly capabilities: readonly [{
+                    readonly name: "Unary Operator";
+                    readonly id: "unary-operator";
+                    readonly supported: "fully";
+                    readonly description: "_Recognize and resolve calls like `+3`, `-3`, ..._";
+                }, {
+                    readonly name: "Binary Operator";
+                    readonly id: "binary-operator";
+                    readonly supported: "fully";
+                    readonly description: "_Recognize and resolve calls like `3 + 4`, `3 * 4`, ..._";
+                    readonly capabilities: readonly [{
+                        readonly name: "Special Operator";
+                        readonly id: "special-operator";
+                        readonly supported: "fully";
+                        readonly description: "_Recognize and resolve calls like `3 %in% 4`, `3 %*% 4`, ..._";
+                    }, {
+                        readonly name: "Model Formula";
+                        readonly id: "model-formula";
+                        readonly supported: "partially";
+                        readonly description: "_Recognize and resolve calls like `y ~ x`, `y ~ x + z`, ... including their implicit redefinitions of some functions._ Currently, we do not handle their redefinition and only treat model formulas as normal binary operators";
+                    }, {
+                        readonly name: "Assignments and Bindings";
+                        readonly id: "assignments-and-bindings";
+                        readonly capabilities: readonly [{
+                            readonly name: "Local Left Assignment";
+                            readonly id: "local-left-assignment";
+                            readonly supported: "fully";
+                            readonly description: "_Handle `x <- 3`, `x$y <- 3`, ..._";
+                        }, {
+                            readonly name: "Local Right Assignment";
+                            readonly id: "local-right-assignment";
+                            readonly supported: "fully";
+                            readonly description: "_Handle `3 -> x`, `3 -> x$y`, ..._";
+                        }, {
+                            readonly name: "Local Equal Assignment";
+                            readonly id: "local-equal-assignment";
+                            readonly supported: "fully";
+                            readonly description: "_Handle `x = 3`, `x$y := 3`, ..._";
+                        }, {
+                            readonly name: "Super Left Assignment";
+                            readonly id: "super-left-assignment";
+                            readonly supported: "fully";
+                            readonly description: "_Handle `x <<- 42`, `x$y <<- 42`, ..._";
+                        }, {
+                            readonly name: "Super Right Assignment";
+                            readonly id: "super-right-assignment";
+                            readonly supported: "fully";
+                            readonly description: "_Handle `42 ->> x`, `42 ->> x$y`, ..._";
+                        }, {
+                            readonly name: "Return Value of Assignments";
+                            readonly id: "return-value-of-assignments";
+                            readonly supported: "fully";
+                            readonly description: "_Handle `x <- 3` returning `3`, e.g., in `x <- y <- 3`_";
+                        }, {
+                            readonly name: "Assignment Functions";
+                            readonly id: "assignment-functions";
+                            readonly supported: "partially";
+                            readonly description: "_Handle `assign(x, 3)`, `delayedAssign(x, 3)`, ..._ Currently we can not handle all of them and tests are rare.";
+                        }, {
+                            readonly name: "Range Assignment";
+                            readonly id: "range-assignment";
+                            readonly supported: "fully";
+                            readonly description: "_Handle `x[1:3] <- 3`, `x$y[1:3] <- 3`, ..._";
+                        }, {
+                            readonly name: "Replacement Functions";
+                            readonly id: "replacement-functions";
+                            readonly supported: "partially";
+                            readonly description: "_Handle `x[i] <- 3`, `x$y <- 3`, ... as `` `[<-`(x, 3) ``, ..._ Currently work in progress as part of the desugaring but still untested.";
+                        }, {
+                            readonly name: "Locked Bindings";
+                            readonly id: "locked-bindings";
+                            readonly supported: "not";
+                            readonly description: "_Handle `lockBinding(x, 3)`, ..._";
+                        }];
+                    }];
+                }];
+            }, {
+                readonly name: "Control-Flow";
+                readonly id: "control-flow";
+                readonly capabilities: readonly [{
+                    readonly name: "if";
+                    readonly id: "if";
+                    readonly supported: "fully";
+                    readonly description: "_Handle `if (x) y else z`, `if (x) y`, ..._";
+                }, {
+                    readonly name: "for loop";
+                    readonly id: "for-loop";
+                    readonly supported: "fully";
+                    readonly description: "_Handle `for (i in 1:3) print(i)`, ..._";
+                }, {
+                    readonly name: "while loop";
+                    readonly id: "while-loop";
+                    readonly supported: "fully";
+                    readonly description: "_Handle `while (x) b`, ..._";
+                }, {
+                    readonly name: "repeat loop";
+                    readonly id: "repeat-loop";
+                    readonly supported: "fully";
+                    readonly description: "_Handle `repeat {b; if (x) break}`, ..._";
+                }, {
+                    readonly name: "break";
+                    readonly id: "break";
+                    readonly supported: "fully";
+                    readonly description: "_Handle `break` (including `break()`) ..._";
+                }, {
+                    readonly name: "next";
+                    readonly id: "next";
+                    readonly supported: "fully";
+                    readonly description: "_Handle `next` (including `next()`) ..._";
+                }, {
+                    readonly name: "switch";
+                    readonly id: "switch";
+                    readonly supported: "fully";
+                    readonly description: "_Handle `switch(3, \"a\", \"b\", \"c\")`, ..._";
+                }, {
+                    readonly name: "return";
+                    readonly id: "return";
+                    readonly supported: "fully";
+                    readonly description: "_Handle `return(3)`, ... in function definitions_";
+                }, {
+                    readonly name: "exceptions";
+                    readonly id: "exceptions";
+                    readonly supported: "not";
+                    readonly description: "_Handle `try`, `stop`, ..._";
+                }];
+            }, {
+                readonly name: "Function Definitions";
+                readonly id: "function-definitions";
+                readonly capabilities: readonly [{
+                    readonly name: "Normal";
+                    readonly id: "normal-definition";
+                    readonly supported: "fully";
+                    readonly description: "_Handle `function() 3`, ..._";
+                }, {
+                    readonly name: "Formals";
+                    readonly id: "formals";
+                    readonly capabilities: readonly [{
+                        readonly name: "Named";
+                        readonly id: "formals-named";
+                        readonly supported: "fully";
+                        readonly description: "_Handle `function(x) x`, ..._";
+                    }, {
+                        readonly name: "Default";
+                        readonly id: "formals-default";
+                        readonly supported: "fully";
+                        readonly description: "_Handle `function(x = 3) x`, ..._";
+                    }, {
+                        readonly name: "Dot-Dot-Dot";
+                        readonly id: "formals-dot-dot-dot";
+                        readonly supported: "fully";
+                        readonly description: "_Handle `function(...) 3`, ..._";
+                    }, {
+                        readonly name: "Promises";
+                        readonly id: "formals-promises";
+                        readonly supported: "partially";
+                        readonly description: "_Handle `function(x = y) { y <- 3; x }`, `function(x = { x <- 3; x}) { x * x }`, ..._ We _try_ to identify promises correctly but this is really rudimentary.";
+                    }];
+                }, {
+                    readonly name: "Implicit Return";
+                    readonly id: "implicit-return";
+                    readonly supported: "fully";
+                    readonly description: "_Handle the return of `function() 3`, ..._";
+                }, {
+                    readonly name: "Lambda Syntax";
+                    readonly id: "lambda-syntax";
+                    readonly supported: "fully";
+                    readonly description: "_Support `\\(x) x`, ..._";
+                }];
+            }, {
+                readonly name: "Important Built-Ins";
+                readonly id: "important-built-ins";
+                readonly capabilities: readonly [{
+                    readonly name: "Non-Strict Logical Operators";
+                    readonly id: "non-strict-logical-operators";
+                    readonly supported: "fully";
+                    readonly description: "_Handle `&&`, `||`, ..._";
+                }, {
+                    readonly name: "Pipe and Pipe-Bind";
+                    readonly id: "built-in-pipe-and-pipe-bind";
+                    readonly supported: "partially";
+                    readonly description: "_Handle the [new (4.1) pipe and pipe-bind syntax](https://www.r-bloggers.com/2021/05/the-new-r-pipe/): `|>`, and `=>`._ We have not enough tests and do not support pipe-bind.";
+                }, {
+                    readonly name: "Sequencing";
+                    readonly id: "built-in-sequencing";
+                    readonly supported: "not";
+                    readonly description: "_Handle `:`, `seq`, ... as they are used often._";
+                }, {
+                    readonly name: "Internal and Primitive Functions";
+                    readonly id: "built-in-internal-and-primitive-functions";
+                    readonly supported: "not";
+                    readonly description: "_Handle `.Internal`, `.Primitive`, ..._ In general we can not handle them as they refer to non-R code. We currently do not support them when used with the function.";
+                }, {
+                    readonly name: "Options";
+                    readonly id: "built-in-options";
+                    readonly supported: "not";
+                    readonly description: "_Handle `options`, `getOption`, ..._ Currently, we do not support the function at all.";
+                }, {
+                    readonly name: "Help";
+                    readonly id: "built-in-help";
+                    readonly supported: "partially";
+                    readonly description: "_Handle `help`, `?`, ..._ We do not support the function in a sensible way but just ignore it (although this does not happen resolved).";
+                }, {
+                    readonly name: "Reflection / \"Computing on the Language\"";
+                    readonly id: "reflection-\"computing-on-the-language\"";
+                    readonly capabilities: readonly [{
+                        readonly name: "Get Function Structure";
+                        readonly id: "get-function-structure";
+                        readonly supported: "not";
+                        readonly description: "_Handle `body`, `formals`, `environment` to access the respective parts of a function._ We do not support the functions at all.";
+                    }, {
+                        readonly name: "Modify Function Structure";
+                        readonly id: "modify-function-structure";
+                        readonly supported: "not";
+                        readonly description: "_Handle `body<-`, `formals<-`, `environment<-` to modify the respective parts of a function._ We do not support the functions at all.";
+                    }, {
+                        readonly name: "Quoting";
+                        readonly id: "built-in-quoting";
+                        readonly supported: "partially";
+                        readonly description: "_Handle `quote`, `substitute`, `bquote`, ..._ We partially ignore some of them but most likely not all.";
+                    }, {
+                        readonly name: "Evaluation";
+                        readonly id: "built-in-evaluation";
+                        readonly supported: "not";
+                        readonly description: "_Handle `eval`, `evalq`, `eval.parent`, ..._ We do not handle them at all.";
+                    }, {
+                        readonly name: "Parsing";
+                        readonly id: "built-in-parsing";
+                        readonly supported: "not";
+                        readonly description: "_Handle `parse`, `deparse`, ..._ We handle them as unknown function calls, but not specifically besides that.";
+                    }];
+                }];
+            }];
+        }, {
+            readonly name: "Literal Values";
+            readonly id: "literal-values";
+            readonly capabilities: readonly [{
+                readonly name: "Numbers";
+                readonly id: "numbers";
+                readonly supported: "fully";
+                readonly description: "_Recognize numbers like `3`, `3.14`, `NA`, float-hex, ..._";
+            }, {
+                readonly name: "Strings";
+                readonly id: "strings";
+                readonly supported: "fully";
+                readonly description: "_Recognize strings like `\"a\"`, `'b'`, ..._";
+                readonly capabilities: readonly [{
+                    readonly name: "Raw Strings";
+                    readonly id: "raw-strings";
+                    readonly supported: "fully";
+                    readonly description: "_Recognize raw strings like `r\"(a)\"`, ..._";
+                }];
+            }, {
+                readonly name: "Logical";
+                readonly id: "logical";
+                readonly supported: "fully";
+                readonly description: "_Recognize the logicals `TRUE` and `FALSE`, ..._";
+            }, {
+                readonly name: "NULL";
+                readonly id: "null";
+                readonly supported: "fully";
+                readonly description: "_Recognize `NULL`_";
+            }, {
+                readonly name: "Inf and NaN";
+                readonly id: "inf-and-nan";
+                readonly supported: "fully";
+                readonly description: "_Recognize `Inf` and `NaN`_";
+            }];
+        }];
+    }, {
+        readonly name: "Non-Standard Evaluations/Semantics";
+        readonly id: "non-standard-evaluations-semantics";
+        readonly capabilities: readonly [{
+            readonly name: "Recycling";
+            readonly id: "recycling";
+            readonly supported: "not";
+            readonly description: "_Handle recycling of vectors as explained in [Advanced R](https://adv-r.hadley.nz/vectors-chap.html)._ We do not support recycling.";
+        }, {
+            readonly name: "Vectorized Operator or Functions";
+            readonly id: "vectorized-operator-or-functions";
+            readonly supported: "not";
+            readonly description: "_Handle vectorized operations as explained in [Advanced R](https://adv-r.hadley.nz/perf-improve.html?q=vectorised#vectorise)._ We do not support vectorized operations.";
+        }, {
+            readonly name: "Hooks";
+            readonly id: "hooks";
+            readonly supported: "not";
+            readonly description: "_Handle hooks like [`userhooks`](https://stat.ethz.ch/R-manual/R-devel/library/base/html/userhooks.html) and [`on.exit`](https://www.rdocumentation.org/packages/base/versions/3.6.2/topics/on.exit)._ We do not support hooks.";
+        }, {
+            readonly name: "Precedence";
+            readonly id: "precedence";
+            readonly supported: "fully";
+            readonly description: "_Handle the precedence of operators as explained in the [Documentation](https://rdrr.io/r/base/Syntax.html)._ We handle the precedence of operators (implicitly with the parser).";
+        }, {
+            readonly name: "Attributes";
+            readonly id: "attributes";
+            readonly capabilities: readonly [{
+                readonly name: "User-Defined";
+                readonly id: "user-defined";
+                readonly supported: "not";
+                readonly description: "_Handle [attributes](https://cran.r-project.org/doc/manuals/r-release/R-lang.html#Attributes) like `attr`, `attributes`, ..._ We do not support attributes.";
+            }, {
+                readonly name: "Built-In";
+                readonly id: "built-in";
+                readonly supported: "not";
+                readonly description: "_Handle built-in attributes like `dim`, ..._ We do not support them.";
+            }];
+        }];
+    }, {
+        readonly name: "Types";
+        readonly id: "types";
+        readonly capabilities: readonly [{
+            readonly name: "Primitive";
+            readonly id: "types-primitive";
+            readonly supported: "not";
+            readonly description: "_Recognize and resolve primitive types like `numeric`, `character`, ..._ We do not support typing currently.";
+        }, {
+            readonly name: "Non-Primitive";
+            readonly id: "types-non-primitive";
+            readonly supported: "not";
+            readonly description: "_Recognize and resolve non-primitive/composite types._ We do not support typing currently.";
+        }, {
+            readonly name: "Inference";
+            readonly id: "types-inference";
+            readonly supported: "not";
+            readonly description: "_Infer types from the code._ We do not support typing currently.";
+        }, {
+            readonly name: "Coercion";
+            readonly id: "types-coercion";
+            readonly supported: "not";
+            readonly description: "_Handle coercion of types._ We do not support typing currently.";
+        }, {
+            readonly name: "Object-Oriented Programming";
+            readonly id: "object-oriented-programming";
+            readonly capabilities: readonly [{
+                readonly name: "S3";
+                readonly id: "oop-s3";
+                readonly note: "https://adv-r.hadley.nz/s3.html";
+                readonly supported: "not";
+                readonly description: "_Handle S3 classes and methods as one unit (with attributes etc.). Including Dispatch and Inheritance._ We do not support typing currently and do not handle objects of these classes \"as units.\"";
+            }, {
+                readonly name: "S4";
+                readonly id: "oop-s4";
+                readonly note: "https://adv-r.hadley.nz/s4.html";
+                readonly supported: "not";
+                readonly description: "_Handle S4 classes and methods as one unit. Including Dispatch and Inheritance_ We do not support typing currently and do not handle objects of these classes \"as units.\"";
+            }, {
+                readonly name: "R6";
+                readonly id: "oop-r6";
+                readonly note: "https://adv-r.hadley.nz/r6.html";
+                readonly supported: "not";
+                readonly description: "_Handle R6 classes and methods as one unit. Including Dispatch and Inheritance, as well as its Reference Semantics, Access Control, Finalizers, and Introspection._ We do not support typing currently and do not handle objects of these classes \"as units.\"";
+            }, {
+                readonly name: "R7/S7";
+                readonly id: "r7-s7";
+                readonly note: "https://www.r-bloggers.com/2022/12/what-is-r7-a-new-oop-system-for-r/, https://cran.r-project.org/web/packages/S7/index.html";
+                readonly supported: "not";
+                readonly description: "_Handle R7 classes and methods as one unit. Including Dispatch and Inheritance, as well as its Reference Semantics, Validators, ..._ We do not support typing currently and do not handle objects of these classes \"as units.\"";
+            }];
+        }];
+    }, {
+        readonly name: "Structure";
+        readonly id: "structure";
+        readonly capabilities: readonly [{
+            readonly name: "Comments";
+            readonly id: "comments";
+            readonly supported: "fully";
+            readonly description: "_Recognize comments like `# this is a comment`, ... and line-directives_";
+        }, {
+            readonly name: "Semicolons";
+            readonly id: "semicolons";
+            readonly supported: "fully";
+            readonly description: "_Recognize and resolve semicolons like `a; b; c`, ..._";
+        }, {
+            readonly name: "Newlines";
+            readonly id: "newlines";
+            readonly supported: "fully";
+            readonly description: "_Recognize and resolve newlines like `a\nb\nc`, ..._";
+        }];
+    }, {
+        readonly name: "System, I/O, FFI, and Other Files";
+        readonly id: "system-i-o-ffi-and-other-files";
+        readonly capabilities: readonly [{
+            readonly name: "Sourcing External Files";
+            readonly id: "sourcing-external-files";
+            readonly supported: "partially";
+            readonly description: "_Handle `source`, `sys.source`, ..._ We are currently working on supporting the inclusion of external files. Currently we can handle `source`.";
+        }, {
+            readonly name: "Handling Binary Riles";
+            readonly id: "handling-binary-riles";
+            readonly supported: "not";
+            readonly description: "_Handle files dumped with, e.g., [`save`](https://www.rdocumentation.org/packages/base/versions/3.6.2/topics/save), ... due to their frequent usage._ We do not support binary files.";
+        }, {
+            readonly name: "I/O";
+            readonly id: "i-o";
+            readonly supported: "not";
+            readonly description: "_Handle `read.csv`, `write.csv`, ..._ We do not support I/O for the time being but treat them as unknown function calls.";
+        }, {
+            readonly name: "Foreign Function Interface";
+            readonly id: "foreign-function-interface";
+            readonly supported: "not";
+            readonly description: "_Handle `.Fortran`, `C`,..._ We do not support FFI but treat them as unknown function calls.";
+        }, {
+            readonly name: "System Calls";
+            readonly id: "system-calls";
+            readonly supported: "not";
+            readonly description: "_Handle [`system`](https://www.rdocumentation.org/packages/base/versions/3.6.2/topics/system), `system.*`, ..._ We do not support system calls but treat them as unknown function calls.";
+        }];
+    }, {
+        readonly name: "Pre-Processors/external Tooling";
+        readonly id: "pre-processors-external-tooling";
+        readonly supported: "not";
+        readonly description: "_Handle pre-processors like `knitr`, `rmarkdown`, `roxygen2` ..._ We do not support pre-processors for the time being (being unable to handle things like `@importFrom`)";
+    }];
+};