@eagleoutice/flowr 1.5.2 → 2.0.0

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

@@ -0,0 +1,19 @@
+import type { FlowrCapability } from './types';
+import { flowrCapabilities } from './data';
+type CapabilityIdFilter<T extends FlowrCapability, Filter> = T extends Filter ? T['id'] : never;
+/** Recursively extract all valid identifiers (which have the given support predicate) */
+type ExtractAllIds<T extends FlowrCapability, Filter = FlowrCapability> = T extends {
+    readonly capabilities: infer U;
+} ? U extends readonly FlowrCapability[] ? (CapabilityIdFilter<T, Filter> | ExtractAllIds<U[number]>) : CapabilityIdFilter<T, Filter> : CapabilityIdFilter<T, Filter>;
+type Capabilities = (typeof flowrCapabilities)['capabilities'][number];
+export type FlowrCapabilityId = ExtractAllIds<Capabilities>;
+export type SupportedFlowrCapabilityId = ExtractAllIds<Capabilities, {
+    readonly supported: 'partially' | 'fully';
+}>;
+type PathToCapability = readonly number[];
+export interface FlowrCapabilityWithPath extends FlowrCapability {
+    path: PathToCapability;
+}
+export declare function getCapabilityById(id: FlowrCapabilityId): FlowrCapabilityWithPath;
+export declare function getAllCapabilities(): readonly FlowrCapabilityWithPath[];
+export {};

package/r-bridge/data/get.js

@@ -0,0 +1,51 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.getAllCapabilities = exports.getCapabilityById = void 0;
+const assert_1 = require("../../util/assert");
+const data_1 = require("./data");
+function search(id, capabilities, path = []) {
+    let idx = 0;
+    for (const capability of capabilities) {
+        idx++; // index by one :)
+        if (capability.id === id) {
+            return { ...capability, path: [...path, idx] };
+        }
+        if (capability.capabilities) {
+            const found = search(id, capability.capabilities, [...path, idx]);
+            if (found) {
+                return found;
+            }
+        }
+    }
+    return undefined;
+}
+const capabilityCache = new Map();
+function getCapabilityById(id) {
+    const cached = capabilityCache.get(id);
+    if (cached) {
+        return cached;
+    }
+    const value = search(id, data_1.flowrCapabilities.capabilities);
+    (0, assert_1.guard)(value !== undefined, () => `Could not find capability with id ${id}`);
+    capabilityCache.set(id, value);
+    return value;
+}
+exports.getCapabilityById = getCapabilityById;
+function getAllCapabilities() {
+    const result = [];
+    function traverse(capabilities, currentPath = []) {
+        let idx = 0;
+        for (const capability of capabilities) {
+            idx++;
+            const nextPath = [...currentPath, idx];
+            result.push({ ...capability, path: nextPath });
+            if (capability.capabilities) {
+                traverse(capability.capabilities, nextPath);
+            }
+        }
+    }
+    traverse(data_1.flowrCapabilities.capabilities, []);
+    return result;
+}
+exports.getAllCapabilities = getAllCapabilities;
+//# sourceMappingURL=get.js.map

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

@@ -0,0 +1 @@
+export {};

package/r-bridge/data/print.js

@@ -0,0 +1,58 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const data_1 = require("./data");
+const supportedSymbolMap = new Map([
+    ['not', ':red_circle:'],
+    ['partially', ':large_orange_diamond:'],
+    ['fully', ':green_square:']
+]);
+function printSingleCapability(depth, index, capability) {
+    const indent = '    '.repeat(depth);
+    const indexStr = index.toString().padStart(2, ' ');
+    const nextLineIndent = '  '.repeat(depth + indexStr.length);
+    const mainLine = `${indent}${indexStr}. **${capability.name}** (<a id='${capability.id}'>\`${capability.id}\`</a>)`;
+    let nextLine = '';
+    if (capability.supported) {
+        nextLine += `${supportedSymbolMap.get(capability.supported)} `;
+    }
+    if (capability.description) {
+        nextLine += capability.description;
+    }
+    if (capability.note) {
+        nextLine += `\\\n${nextLineIndent}_${capability.note}_`;
+    }
+    return nextLine ? `${mainLine}\\\n${nextLineIndent}${nextLine}` : mainLine;
+}
+function printAsMarkdown(capabilities, depth = 0, lines = []) {
+    for (let i = 0; i < capabilities.length; i++) {
+        const capability = capabilities[i];
+        const result = printSingleCapability(depth, i + 1, capability);
+        lines.push(result);
+        if (capability.capabilities) {
+            printAsMarkdown(capability.capabilities, depth + 1, lines);
+        }
+    }
+    return lines.join('\n');
+}
+function getPreamble() {
+    const currentDateAndTime = new Date().toISOString().replace('T', ', ').replace(/\.\d+Z$/, ' UTC');
+    return `_This document was generated automatically from '${module.filename}' on ${currentDateAndTime} summarizig flowR's current capabilities_
+
+The code-font behind each capability name is a link to the capability's id. This id can be used to reference the capability in a labeled test within flowR.
+Besides, we use colored bullets like this:
+
+| <!-- -->               | <!-- -->                                              |
+| ---------------------- | ----------------------------------------------------- |
+| :green_square:         | _flowR_ is capable of handling this feature fully     |
+| :large_orange_diamond: | _flowR_ is capable of handling this feature partially |
+| :red_circle:           | _flowR_ is not capable of handling this feature       |
+
+:cloud: This could be a feature diagram... :cloud:
+
+`;
+}
+/** if we run this script, we want a markdown representation of the capabilities */
+if (require.main === module) {
+    console.log(getPreamble() + printAsMarkdown(data_1.flowrCapabilities.capabilities));
+}
+//# sourceMappingURL=print.js.map

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

@@ -0,0 +1,33 @@
+declare const enum RequiredFeature {
+    /** https://github.com/Code-Inspect/flowr/labels/typing */
+    Typing = 0,
+    /** https://github.com/Code-Inspect/flowr/labels/abstract%20interpretation */
+    AbstractInterpretation = 1
+}
+export interface FlowrCapability {
+    /** The human-readable name of the capability */
+    readonly name: string;
+    /**
+     * The unique identifier of the capability, used to refer to it independent of the location.
+     * We could use a key-value mapping. However, this way, an id is self-contained and can be moved around as one object.
+     */
+    readonly id: string;
+    /** A list of features that are required for the capability, extend at need. */
+    readonly needs?: RequiredFeature[];
+    readonly description?: string;
+    readonly note?: string;
+    /** The level of support for the capability, undefined if it is a meta-capability that does not need such an attribute */
+    readonly supported?: 'not' | 'partially' | 'fully';
+    readonly capabilities?: readonly FlowrCapability[];
+}
+export interface FlowrCapabilities {
+    /** The human-readable name of the capabilities */
+    readonly name: string;
+    /** A description of the capabilities */
+    readonly description: string;
+    /** The version of the capabilities */
+    readonly version: string;
+    /** A list of the capabilities */
+    readonly capabilities: readonly FlowrCapability[];
+}
+export {};

package/r-bridge/data/types.js

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

package/r-bridge/init.d.ts

@@ -0,0 +1,3 @@
+export declare const ErrorMarker = "err";
+/** Command(s) to be issued at the start of each shell */
+export declare function initCommand(eol: string): string;

package/r-bridge/init.js

@@ -0,0 +1,22 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.initCommand = exports.ErrorMarker = void 0;
+const convert_values_1 = require("./lang-4.x/convert-values");
+exports.ErrorMarker = 'err';
+/** Command(s) to be issued at the start of each shell */
+function initCommand(eol) {
+    /* define the get function complete wrapped in a try so that we can handle failures gracefully on stdout
+     * furthermore, we compile for performance reasons
+     */
+    return 'flowr_get_ast<-compiler::cmpfun(function(...){tryCatch({'
+        /* the actual code to parse the R code, ... allows us to keep the old 'file=path' and 'text=content' semantics. we define flowr_output using the super assignment to persist it in the env! */
+        + 'flowr_output<<-getParseData(parse(...,keep.source=TRUE),includeText=TRUE);'
+        /* json conversion of the output, dataframe="values" allows us to receive a list of lists (which is more compact)!
+         * so we do not depend on jsonlite and friends, we do so manually (:sparkles:)
+         */
+        + 'cat(paste0(sprintf("[%s,%s,%s,%s,%s,%s,%s,%s,%s]",flowr_output$line1,flowr_output$col1,flowr_output$line2,flowr_output$col2,flowr_output$id,flowr_output$parent,encodeString(flowr_output$token,quote="\\""),ifelse(flowr_output$terminal,"true","false"),encodeString(flowr_output$text,quote="\\"")),collapse=","))'
+        /* error handling (just produce the marker) */
+        + `},error=function(e){cat("${exports.ErrorMarker}")});cat(${(0, convert_values_1.ts2r)(eol)})},options=compiler::setCompilerOptions(optimize=3));`;
+}
+exports.initCommand = initCommand;
+//# sourceMappingURL=init.js.map

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

@@ -1,5 +1,6 @@
-import type { NodeId, ParentInformation } from './processing';
 import type { RNode } from './model';
+import type { NodeId } from './processing/node-id';
+import type { ParentInformation } from './processing/decorate';
 /**
  * Collects all node ids within a tree given by a respective root node
  *

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

@@ -1,7 +1,7 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.collectAllIds = void 0;
-const processing_1 = require("./processing");
+const visitor_1 = require("./processing/visitor");
 /**
  * Collects all node ids within a tree given by a respective root node
  *
@@ -10,7 +10,7 @@ const processing_1 = require("./processing");
  */
 function collectAllIds(nodes, stop = () => false) {
     const ids = new Set();
-    (0, processing_1.visitAst)(nodes, (node) => {
+    (0, visitor_1.visitAst)(nodes, (node) => {
         if (stop(node)) {
             return true;
         }

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

@@ -1,9 +1,29 @@
 import type { SourceRange } from '../../../../util/range';
 import type { RType } from './type';
 import type { MergeableRecord } from '../../../../util/objects';
-import type { RNa, RNull } from '../../values';
-import type { 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 type { OtherInfoNode } from './nodes/info';
+import type { RNa, RNull } from '../../convert-values';
+import type { RNumber } from './nodes/r-number';
+import type { RString } from './nodes/r-string';
+import type { RLogical } from './nodes/r-logical';
+import type { RSymbol } from './nodes/r-symbol';
+import type { RComment } from './nodes/r-comment';
+import type { RBreak } from './nodes/r-break';
+import type { RNext } from './nodes/r-next';
+import type { RLineDirective } from './nodes/r-line-directive';
+import type { RForLoop } from './nodes/r-for-loop';
+import type { RRepeatLoop } from './nodes/r-repeat-loop';
+import type { RWhileLoop } from './nodes/r-while-loop';
+import type { RIfThenElse } from './nodes/r-if-then-else';
+import type { RFunctionDefinition } from './nodes/r-function-definition';
+import type { RFunctionCall } from './nodes/r-function-call';
+import type { RParameter } from './nodes/r-parameter';
+import type { RArgument } from './nodes/r-argument';
+import type { RExpressionList } from './nodes/r-expression-list';
+import type { RIndexAccess, RNamedAccess } from './nodes/r-access';
+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 interface used to say that there are additional decorations (see {@link Base}). */
 export interface NoInfo {
 }
@@ -31,7 +51,7 @@ interface Source {
     additionalTokens?: OtherInfoNode[];
 }
 /**
- * Provides the common base of all {@link RNode | RNodes}.
+ * 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`
@@ -44,7 +64,7 @@ export interface Base<Info, LexemeType = string> extends MergeableRecord {
     info: Info & Source;
 }
 export interface WithChildren<Info, Children extends Base<Info, string | undefined>> {
-    children: Children[];
+    children: readonly Children[];
 }
 /**
  * A helper interface we use to "mark" leaf nodes.
@@ -124,4 +144,5 @@ export type ROther<Info> = RComment<Info> | RLineDirective<Info>;
  * 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 type OtherInfoNode = RNode | RDelimiter;
 export {};

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

@@ -1,6 +1,7 @@
 import type { Base, Location, NoInfo, RNode } from '../model';
 import type { RType } from '../type';
-import type { RArgument } from './r-argument';
+import type { RArgument, RUnnamedArgument } from './r-argument';
+import type { EmptyArgument } from './r-function-call';
 /**
  * Represents an R Indexing operation with `$`, `@`, `[[`, or `[`.
  */
@@ -12,13 +13,13 @@ interface RAccessBase<Info = NoInfo> extends Base<Info>, Location {
 }
 export interface RNamedAccess<Info = NoInfo> extends RAccessBase<Info> {
     operator: '$' | '@';
-    access: string;
+    access: [RUnnamedArgument<Info>];
 }
 /** 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)[];
+    access: readonly (RArgument<Info> | typeof EmptyArgument)[];
 }
 export type RAccess<Info = NoInfo> = RNamedAccess<Info> | RIndexAccess<Info>;
 export {};

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

@@ -9,3 +9,7 @@ export interface RArgument<Info = NoInfo> extends Base<Info>, Location {
     name: RSymbol<Info> | undefined;
     value: RNode<Info> | undefined;
 }
+export interface RUnnamedArgument<Info = NoInfo> extends RArgument<Info> {
+    name: undefined;
+    value: RNode<Info>;
+}

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

@@ -1,25 +1,8 @@
 import type { Base, Location, NoInfo, RNode } from '../model';
 import type { RType } from '../type';
-import type { 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-expression-list.d.ts

@@ -1,6 +1,8 @@
 import type { Base, Location, NoInfo, RNode, WithChildren } from '../model';
 import type { RType } from '../type';
+import type { RSymbol } from './r-symbol';
 export interface RExpressionList<Info = NoInfo> extends WithChildren<Info, RNode<Info>>, Base<Info, string | undefined>, Partial<Location> {
     readonly type: RType.ExpressionList;
-    readonly content?: string;
+    /** encodes wrappers like `{}` or `()` */
+    readonly grouping: undefined | [start: RSymbol<Info>, end: RSymbol<Info>];
 }

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

@@ -2,6 +2,8 @@ import type { Base, Location, NoInfo, RNode } from '../model';
 import type { RType } from '../type';
 import type { RSymbol } from './r-symbol';
 import type { RArgument } from './r-argument';
+export declare const EmptyArgument = "<>";
+export type RFunctionArgument<Info = NoInfo> = RArgument<Info> | typeof EmptyArgument;
 /**
  * Calls of functions like `a()` and `foo(42, "hello")`.
  *
@@ -11,8 +13,8 @@ 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)[];
+    /** arguments can be empty, for example when calling as `a(1, ,3)` */
+    readonly arguments: readonly RFunctionArgument<Info>[];
 }
 /**
  * Direct calls of functions like `(function(x) { x })(3)`.
@@ -23,9 +25,9 @@ export interface RUnnamedFunctionCall<Info = NoInfo> extends Base<Info>, Locatio
     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 */
+    /** marks function calls like `3 %xx% 4` which have been written in special infix notation; deprecated in v2 */
     infixSpecial?: boolean;
     /** arguments can be undefined, for example when calling as `a(1, ,3)` */
-    arguments: (RArgument<Info> | undefined)[];
+    readonly arguments: readonly RFunctionArgument<Info>[];
 }
 export type RFunctionCall<Info = NoInfo> = RNamedFunctionCall<Info> | RUnnamedFunctionCall<Info>;

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

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

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

@@ -1,10 +1,9 @@
-import type { Base, Location, NoInfo } from '../model';
+import type { Base, Location, NoInfo, RNode } from '../model';
 import type { RType } from '../type';
 import type { RParameter } from './r-parameter';
-import type { 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>;
+    body: RNode<Info>;
 }

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

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

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

@@ -1,6 +1,6 @@
 import type { Leaf, Location, NoInfo } from '../model';
 import type { RType } from '../type';
-import type { RStringValue } from '../../../values';
+import type { RStringValue } from '../../../convert-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-symbol.js

@@ -1,9 +1,9 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.isSpecialSymbol = void 0;
-const values_1 = require("../../../values");
+const convert_values_1 = require("../../../convert-values");
 function isSpecialSymbol(symbol) {
-    return symbol.content === values_1.RNull || symbol.content === values_1.RNa;
+    return symbol.content === convert_values_1.RNull || symbol.content === convert_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

@@ -1,18 +1,7 @@
 import type { Base, Location, NoInfo, RNode } from '../model';
 import type { RType } from '../type';
-import type { 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/operators.d.ts

@@ -1,5 +1,6 @@
 import type { MergeableRecord } from '../../../../util/objects';
 import { RawRType } from './type';
+import type { SupportedFlowrCapabilityId } from '../../../data/get';
 /**
  * Just a type-alias so that type declarations become more readable.
  *
@@ -14,33 +15,20 @@ export declare const enum OperatorArity {
     Binary = 2,
     Both = 3
 }
-export type UnaryOperatorFlavor = 'arithmetic' | 'logical' | 'model formula';
-export type BinaryOperatorFlavor = UnaryOperatorFlavor | 'comparison' | 'assignment';
-export type BinaryOperatorFlavorInAst = BinaryOperatorFlavor | 'special';
 export type OperatorWrittenAs = 'infix' | 'prefix';
 export type OperatorUsedAs = 'assignment' | 'operation' | 'access';
-export type OperatorName = string;
 export interface OperatorInformationValue extends MergeableRecord {
-    name: OperatorName;
+    name: string;
     stringUsedInRAst: RawRType | `%${string}%`;
     stringUsedInternally: string;
-    flavorInRAst: BinaryOperatorFlavorInAst;
-    flavor: BinaryOperatorFlavor;
     writtenAs: OperatorWrittenAs;
     arity: OperatorArity;
     usedAs: OperatorUsedAs;
+    /** The capabilities this operator maps to using the new desugaring */
+    capabilities: readonly SupportedFlowrCapabilityId[];
 }
 export declare const OperatorDatabase: Record<StringUsedInRCode, OperatorInformationValue> & MergeableRecord;
-export declare const ArithmeticOperators: readonly string[];
-export declare const ArithmeticOperatorsRAst: Set<string>;
-export declare const ComparisonOperators: readonly string[];
-export declare const ComparisonOperatorsRAst: Set<string>;
-export declare const LogicalOperators: readonly string[];
-export declare const LogicalOperatorsRAst: Set<string>;
-export declare const ModelFormulaOperators: readonly string[];
-export declare const ModelFormulaOperatorsRAst: Set<string>;
-export declare const Assignments: readonly string[];
-export declare const AssignmentsRAst: Set<string>;
 export declare const Operators: readonly string[];
-export type Operator = (typeof Operators)[number];
+export declare const OperatorsInRAst: Set<string>;
+export declare const UnaryOperatorsInRAst: Set<string>;
 export {};