@eagleoutice/flowr 1.3.11

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

@@ -0,0 +1,127 @@
+import { SourceRange } from '../../../../util/range';
+import { RType } from './type';
+import { MergeableRecord } from '../../../../util/objects';
+import { RNa, RNull } from '../../values';
+import { RExpressionList, RNumber, RSymbol, RLogical, RString, RBinaryOp, RUnaryOp, RIfThenElse, RParameter, RFunctionDefinition, RRepeatLoop, RForLoop, RWhileLoop, RComment, RFunctionCall, RBreak, RNext, RArgument, RNamedAccess, RIndexAccess, RLineDirective, RPipe } from './nodes';
+import { OtherInfoNode } from './nodes/info';
+/** Simply an empty interface used to say that there are additional decorations (see {@link Base}). */
+export interface NoInfo {
+}
+/**
+ * Will be used to reconstruct the source of the given element in the R-ast.
+ * This will not be part of most comparisons as it is mainly of interest to the reconstruction of R code.
+ */
+interface Source {
+    /**
+   * The range is different from the assigned {@link Location} as it refers to the complete source range covered by the given
+   * element.
+   * <p>
+   * As an example for the difference, consider a for loop, the location of `for` will be just the three characters,
+   * but the *range* will be everything including the loop body.
+   */
+    fullRange?: SourceRange;
+    /**
+   * Similar to {@link Source.fullRange} this contains the complete R lexeme of the given element.
+   */
+    fullLexeme?: string;
+    /**
+     * This may contain additional elements that were part of the original R code, but are not part of the normalized R-ast.
+     * This allows inline-comments!
+     */
+    additionalTokens?: OtherInfoNode[];
+}
+/**
+ * Provides the common base of all {@link RNode | RNodes}.
+ *
+ * @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 {
+    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>> {
+    children: 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.
+ * It is intended to help humans understand the code.
+ */
+export interface Leaf<Info = NoInfo, LexemeType = string> extends Base<Info, LexemeType> {
+}
+/**
+ * Indicates, that the respective {@link Base} node has known source code
+ * location information.
+ */
+export interface Location {
+    /**
+     * The location may differ from what is stated in {@link Source#fullRange} as it
+     * represents the location identified by the R parser.
+     *
+     * @see Source#fullRange
+     */
+    location: SourceRange;
+}
+/**
+ * Represents the type of namespaces in the R programming language.
+ * At the moment, this is only the name of the namespace.
+ */
+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).
+ */
+export interface Namespace {
+    /**
+     * The namespace attached to the given node
+     * (e.g., a namespaced symbol in `x::y`).
+     */
+    namespace: NamespaceIdentifier | undefined;
+}
+/**
+ * This subtype of {@link RNode} represents all types of constants
+ * represented in the normalized AST.
+ */
+export type RConstant<Info> = RNumber<Info> | RString<Info> | RLogical<Info> | RSymbol<Info, typeof RNull | typeof RNa>;
+/**
+ * This subtype of {@link RNode} represents all types of {@link Leaf} nodes in the
+ * normalized AST.
+ */
+export type RSingleNode<Info> = RComment<Info> | RSymbol<Info> | RConstant<Info> | RBreak<Info> | RNext<Info> | RLineDirective<Info>;
+/**
+ * This subtype of {@link RNode} represents all looping constructs in the normalized AST.
+ */
+export type RLoopConstructs<Info> = RForLoop<Info> | RRepeatLoop<Info> | RWhileLoop<Info>;
+/**
+ * As an extension to {@link RLoopConstructs}, this subtype of {@link RNode} includes
+ * the {@link RIfThenElse} construct as well.
+ */
+export type RConstructs<Info> = RLoopConstructs<Info> | RIfThenElse<Info>;
+/**
+ * This subtype of {@link RNode} represents all types related to functions
+ * (calls and definitions) in the normalized AST.
+ */
+export type RFunctions<Info> = RFunctionDefinition<Info> | RFunctionCall<Info> | RParameter<Info> | RArgument<Info>;
+/**
+ * This subtype of {@link RNode} represents all types of otherwise hard to categorize
+ * nodes in the normalized AST. At the moment these are the comment-like nodes.
+ */
+export type ROther<Info> = RComment<Info> | RLineDirective<Info>;
+/**
+ * The `RNode` type is the union of all possible nodes in the R-ast.
+ * It should be used whenever you either not care what kind of
+ * node you are dealing with or if you want to handle all possible nodes.
+ * <p>
+ *
+ * All other subtypes (like {@link RLoopConstructs}) listed above
+ * can be used to restrict the kind of node. They do not have to be
+ * exclusive, some nodes can appear in multiple subtypes.
+ */
+export type RNode<Info = NoInfo> = RExpressionList<Info> | RFunctions<Info> | ROther<Info> | RConstructs<Info> | RNamedAccess<Info> | RIndexAccess<Info> | RUnaryOp<Info> | RBinaryOp<Info> | RSingleNode<Info> | RPipe<Info>;
+export {};

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

@@ -0,0 +1,3 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+//# sourceMappingURL=model.js.map

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

@@ -0,0 +1,21 @@
+export * from './r-number';
+export * from './r-string';
+export * from './r-symbol';
+export * from './r-comment';
+export * from './r-line-directive';
+export * from './r-for-loop';
+export * from './r-logical';
+export * from './r-unary-op';
+export * from './r-binary-op';
+export * from './r-while-loop';
+export * from './r-if-then-else';
+export * from './r-repeat-loop';
+export * from './r-access';
+export * from './r-pipe';
+export * from './r-function-call';
+export * from './r-function-definition';
+export * from './r-parameter';
+export * from './r-argument';
+export * from './r-expression-list';
+export * from './r-next';
+export * from './r-break';

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

@@ -0,0 +1,38 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __exportStar = (this && this.__exportStar) || function(m, exports) {
+    for (var p in m) if (p !== "default" && !Object.prototype.hasOwnProperty.call(exports, p)) __createBinding(exports, m, p);
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+__exportStar(require("./r-number"), exports);
+__exportStar(require("./r-string"), exports);
+__exportStar(require("./r-symbol"), exports);
+__exportStar(require("./r-comment"), exports);
+__exportStar(require("./r-line-directive"), exports);
+__exportStar(require("./r-for-loop"), exports);
+__exportStar(require("./r-logical"), exports);
+__exportStar(require("./r-unary-op"), exports);
+__exportStar(require("./r-binary-op"), exports);
+__exportStar(require("./r-while-loop"), exports);
+__exportStar(require("./r-if-then-else"), exports);
+__exportStar(require("./r-repeat-loop"), exports);
+__exportStar(require("./r-access"), exports);
+__exportStar(require("./r-pipe"), exports);
+__exportStar(require("./r-function-call"), exports);
+__exportStar(require("./r-function-definition"), exports);
+__exportStar(require("./r-parameter"), exports);
+__exportStar(require("./r-argument"), exports);
+__exportStar(require("./r-expression-list"), exports);
+__exportStar(require("./r-next"), exports);
+__exportStar(require("./r-break"), exports);
+//# sourceMappingURL=index.js.map

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

@@ -0,0 +1,13 @@
+/**
+ * Other nodes are not part of the normal ast but shipped with the source information.
+ * This way, elements which are uninteresting to us (like braces and parentheses) can be ignored safely for most operations,
+ * but are still available and linked to the corresponding element.
+ * Comments attached within a structure are also part of this.
+ * <p>
+ * In the future, they could be still integrated into the main ast.
+ * @module
+ */
+import { RNode } from '../../model';
+import { RDelimiter } from './r-delimiter';
+export * from './r-delimiter';
+export type OtherInfoNode = RNode | RDelimiter;

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

@@ -0,0 +1,27 @@
+"use strict";
+/**
+ * Other nodes are not part of the normal ast but shipped with the source information.
+ * This way, elements which are uninteresting to us (like braces and parentheses) can be ignored safely for most operations,
+ * but are still available and linked to the corresponding element.
+ * Comments attached within a structure are also part of this.
+ * <p>
+ * In the future, they could be still integrated into the main ast.
+ * @module
+ */
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __exportStar = (this && this.__exportStar) || function(m, exports) {
+    for (var p in m) if (p !== "default" && !Object.prototype.hasOwnProperty.call(exports, p)) __createBinding(exports, m, p);
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+__exportStar(require("./r-delimiter"), exports);
+//# sourceMappingURL=index.js.map

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

@@ -0,0 +1,12 @@
+import { RawRType, RType } from '../../type';
+import { Location } from '../../model';
+import { MergeableRecord } from '../../../../../../util/objects';
+/**
+ * Combines '`{`', '`}`', '`(`', '`)`', and other delimiters used by R, they are ignored for most analysis
+ * but helpful during reconstruction.
+ */
+export interface RDelimiter extends MergeableRecord, Location {
+    readonly type: RType.Delimiter;
+    readonly lexeme: string;
+    readonly subtype: RawRType;
+}

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

@@ -0,0 +1,3 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+//# sourceMappingURL=r-delimiter.js.map

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

@@ -0,0 +1,24 @@
+import { Base, Location, NoInfo, RNode } from '../model';
+import { RType } from '../type';
+import { RArgument } from './r-argument';
+/**
+ * Represents an R Indexing operation with `$`, `@`, `[[`, or `[`.
+ */
+interface RAccessBase<Info = NoInfo> extends Base<Info>, Location {
+    readonly type: RType.Access;
+    /** the accessed container/variable/expression */
+    accessed: RNode<Info>;
+    operator: '[' | '[[' | '$' | '@';
+}
+export interface RNamedAccess<Info = NoInfo> extends RAccessBase<Info> {
+    operator: '$' | '@';
+    access: string;
+}
+/** access can be a number, a variable or an expression that resolves to one, a filter etc. */
+export interface RIndexAccess<Info = NoInfo> extends RAccessBase<Info> {
+    operator: '[' | '[[';
+    /** is null if the access is empty, e.g. `a[,3]` */
+    access: (RArgument<Info> | null)[];
+}
+export type RAccess<Info = NoInfo> = RNamedAccess<Info> | RIndexAccess<Info>;
+export {};

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

@@ -0,0 +1,3 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+//# sourceMappingURL=r-access.js.map

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

@@ -0,0 +1,11 @@
+import { Base, Location, NoInfo, RNode } from '../model';
+import { RType } from '../type';
+import { 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 {
+    readonly type: RType.Argument;
+    name: RSymbol<Info> | undefined;
+    value: RNode<Info> | undefined;
+}

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

@@ -0,0 +1,3 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+//# sourceMappingURL=r-argument.js.map

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

@@ -0,0 +1,25 @@
+import { Base, Location, NoInfo, RNode } from '../model';
+import { RType } from '../type';
+import { BinaryOperatorFlavor } from '../operators';
+export interface RBinaryOp<Info = NoInfo> extends Base<Info>, Location {
+    readonly type: RType.BinaryOp;
+    readonly flavor: BinaryOperatorFlavor;
+    operator: string;
+    lhs: RNode<Info>;
+    rhs: RNode<Info>;
+}
+export interface RLogicalBinaryOp<Info = NoInfo> extends RBinaryOp<Info> {
+    flavor: 'logical';
+}
+export interface RArithmeticBinaryOp<Info = NoInfo> extends RBinaryOp<Info> {
+    flavor: 'arithmetic';
+}
+export interface RComparisonBinaryOp<Info = NoInfo> extends RBinaryOp<Info> {
+    flavor: 'comparison';
+}
+export interface RAssignmentOp<Info = NoInfo> extends RBinaryOp<Info> {
+    flavor: 'assignment';
+}
+export interface RModelFormulaBinaryOp<Info = NoInfo> extends RBinaryOp<Info> {
+    flavor: 'model formula';
+}

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

@@ -0,0 +1,3 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+//# sourceMappingURL=r-binary-op.js.map

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

@@ -0,0 +1,5 @@
+import { Leaf, Location, NoInfo } from '../model';
+import { RType } from '../type';
+export interface RBreak<Info = NoInfo> extends Location, Leaf<Info> {
+    readonly type: RType.Break;
+}

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

@@ -0,0 +1,3 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+//# sourceMappingURL=r-break.js.map

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

@@ -0,0 +1,6 @@
+import { Leaf, Location, NoInfo } from '../model';
+import { RType } from '../type';
+export interface RComment<Info = NoInfo> extends Location, Leaf<Info> {
+    readonly type: RType.Comment;
+    content: string;
+}

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

@@ -0,0 +1,3 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+//# sourceMappingURL=r-comment.js.map

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

@@ -0,0 +1,6 @@
+import { Base, Location, NoInfo, RNode, WithChildren } from '../model';
+import { RType } from '../type';
+export interface RExpressionList<Info = NoInfo> extends WithChildren<Info, RNode<Info>>, Base<Info, string | undefined>, Partial<Location> {
+    readonly type: RType.ExpressionList;
+    readonly content?: string;
+}

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

@@ -0,0 +1,3 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+//# sourceMappingURL=r-expression-list.js.map

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

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

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

@@ -0,0 +1,3 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+//# sourceMappingURL=r-for-loop.js.map

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

@@ -0,0 +1,31 @@
+import { Base, Location, NoInfo, RNode } from '../model';
+import { RType } from '../type';
+import { RSymbol } from './r-symbol';
+import { RArgument } from './r-argument';
+/**
+ * Calls of functions like `a()` and `foo(42, "hello")`.
+ *
+ * @see RUnnamedFunctionCall
+ */
+export interface RNamedFunctionCall<Info = NoInfo> extends Base<Info>, Location {
+    readonly type: RType.FunctionCall;
+    readonly flavor: 'named';
+    functionName: RSymbol<Info>;
+    /** arguments can be undefined, for example when calling as `a(1, ,3)` */
+    arguments: (RArgument<Info> | undefined)[];
+}
+/**
+ * Direct calls of functions like `(function(x) { x })(3)`.
+ *
+ * @see RNamedFunctionCall
+ */
+export interface RUnnamedFunctionCall<Info = NoInfo> extends Base<Info>, Location {
+    readonly type: RType.FunctionCall;
+    readonly flavor: 'unnamed';
+    calledFunction: RNode<Info>;
+    /** marks function calls like `3 %xx% 4` which have been written in special infix notation */
+    infixSpecial?: boolean;
+    /** arguments can be undefined, for example when calling as `a(1, ,3)` */
+    arguments: (RArgument<Info> | undefined)[];
+}
+export type RFunctionCall<Info = NoInfo> = RNamedFunctionCall<Info> | RUnnamedFunctionCall<Info>;

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

@@ -0,0 +1,3 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+//# sourceMappingURL=r-function-call.js.map

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

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

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

@@ -0,0 +1,3 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+//# sourceMappingURL=r-function-definition.js.map

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

@@ -0,0 +1,9 @@
+import { Base, Location, NoInfo, RNode } from '../model';
+import { RType } from '../type';
+import { RExpressionList } from './r-expression-list';
+export interface RIfThenElse<Info = NoInfo> extends Base<Info>, Location {
+    readonly type: RType.IfThenElse;
+    condition: RNode<Info>;
+    then: RExpressionList<Info>;
+    otherwise?: RExpressionList<Info>;
+}

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

@@ -0,0 +1,3 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+//# sourceMappingURL=r-if-then-else.js.map

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

@@ -0,0 +1,7 @@
+import { Leaf, Location, NoInfo } from '../model';
+import { RType } from '../type';
+export interface RLineDirective<Info = NoInfo> extends Location, Leaf<Info> {
+    readonly type: RType.LineDirective;
+    line: number;
+    file: string;
+}

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

@@ -0,0 +1,3 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+//# sourceMappingURL=r-line-directive.js.map

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

@@ -0,0 +1,7 @@
+import { Leaf, Location, NoInfo } from '../model';
+import { RType } from '../type';
+export type RLogicalValue = boolean;
+export interface RLogical<Info = NoInfo> extends Leaf<Info>, Location {
+    readonly type: RType.Logical;
+    content: RLogicalValue;
+}

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

@@ -0,0 +1,3 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+//# sourceMappingURL=r-logical.js.map

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

@@ -0,0 +1,5 @@
+import { Leaf, Location, NoInfo } from '../model';
+import { RType } from '../type';
+export interface RNext<Info = NoInfo> extends Location, Leaf<Info> {
+    readonly type: RType.Next;
+}

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

@@ -0,0 +1,3 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+//# sourceMappingURL=r-next.js.map

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

@@ -0,0 +1,8 @@
+import { Leaf, Location, NoInfo } from '../model';
+import { RType } from '../type';
+import { RNumberValue } from '../../../values';
+/** includes numeric, integer, and complex */
+export interface RNumber<Info = NoInfo> extends Leaf<Info>, Location {
+    readonly type: RType.Number;
+    content: RNumberValue;
+}

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

@@ -0,0 +1,3 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+//# sourceMappingURL=r-number.js.map

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

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

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

@@ -0,0 +1,3 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+//# sourceMappingURL=r-parameter.js.map

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

@@ -0,0 +1,7 @@
+import { Base, Location, NoInfo, RNode } from '../model';
+import { RType } from '../type';
+export interface RPipe<Info = NoInfo> extends Base<Info>, Location {
+    readonly type: RType.Pipe;
+    readonly lhs: RNode<Info>;
+    readonly rhs: RNode<Info>;
+}

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

@@ -0,0 +1,3 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+//# sourceMappingURL=r-pipe.js.map

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

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

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

@@ -0,0 +1,3 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+//# sourceMappingURL=r-repeat-loop.js.map

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

@@ -0,0 +1,7 @@
+import { Leaf, Location, NoInfo } from '../model';
+import { RType } from '../type';
+import { RStringValue } from '../../../values';
+export interface RString<Info = NoInfo> extends Leaf<Info>, Location {
+    readonly type: RType.String;
+    content: RStringValue;
+}

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

@@ -0,0 +1,3 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+//# sourceMappingURL=r-string.js.map

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

@@ -0,0 +1,7 @@
+import { Leaf, Location, Namespace, NoInfo } from '../model';
+import { RType } from '../type';
+export declare function isSpecialSymbol(symbol: RSymbol): boolean;
+export interface RSymbol<Info = NoInfo, T extends string = string> extends Leaf<Info>, Namespace, Location {
+    readonly type: RType.Symbol;
+    content: T;
+}

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

@@ -0,0 +1,9 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.isSpecialSymbol = void 0;
+const values_1 = require("../../../values");
+function isSpecialSymbol(symbol) {
+    return symbol.content === values_1.RNull || symbol.content === values_1.RNa;
+}
+exports.isSpecialSymbol = isSpecialSymbol;
+//# sourceMappingURL=r-symbol.js.map

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

@@ -0,0 +1,18 @@
+import { Base, Location, NoInfo, RNode } from '../model';
+import { RType } from '../type';
+import { UnaryOperatorFlavor } from '../operators';
+export interface RUnaryOp<Info = NoInfo> extends Base<Info>, Location {
+    readonly type: RType.UnaryOp;
+    readonly flavor: UnaryOperatorFlavor;
+    operator: string;
+    operand: RNode<Info>;
+}
+export interface RLogicalUnaryOp<Info = NoInfo> extends RUnaryOp<Info> {
+    flavor: 'logical';
+}
+export interface RArithmeticUnaryOp<Info = NoInfo> extends RUnaryOp<Info> {
+    flavor: 'arithmetic';
+}
+export interface RModelFormulaUnaryOp<Info = NoInfo> extends RUnaryOp<Info> {
+    flavor: 'model formula';
+}

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

@@ -0,0 +1,3 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+//# sourceMappingURL=r-unary-op.js.map