@eagleoutice/flowr 2.9.10 → 2.9.11

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

@@ -1,5 +1,5 @@
-import type { RAstNodeBase, Location, NoInfo } from '../model';
-import type { RType } from '../type';
+import type { RAstNodeBase, Location, NoInfo, RNode } from '../model';
+import { RType } from '../type';
 import type { RExpressionList } from './r-expression-list';
 /**
  * ```r
@@ -10,3 +10,13 @@ export interface RRepeatLoop<Info = NoInfo> extends RAstNodeBase<Info>, Location
     readonly type: RType.RepeatLoop;
     body: RExpressionList<Info>;
 }
+/**
+ * Helper for working with {@link RRepeatLoop} AST nodes.
+ */
+export declare const RRepeatLoop: {
+    readonly name: "RRepeatLoop";
+    /**
+     * Type guard for RRepeatLoop nodes.
+     */
+    readonly is: <Info = object>(this: void, node: RNode<Info> | undefined) => node is RRepeatLoop<Info>;
+};

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

@@ -1,3 +1,17 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
+exports.RRepeatLoop = void 0;
+const type_1 = require("../type");
+/**
+ * Helper for working with {@link RRepeatLoop} AST nodes.
+ */
+exports.RRepeatLoop = {
+    name: 'RRepeatLoop',
+    /**
+     * Type guard for RRepeatLoop nodes.
+     */
+    is(node) {
+        return node?.type === type_1.RType.RepeatLoop;
+    }
+};
 //# sourceMappingURL=r-repeat-loop.js.map

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

@@ -1,6 +1,7 @@
 import type { Leaf, Location, NoInfo, RNode } from '../model';
 import type { RStringValue } from '../../../convert-values';
 import { RType } from '../type';
+import { SemVer } from 'semver';
 /**
  * Represents a string like `"hello"`, including raw strings like `r"(hello)"`.
  * @see {@link isRString} - to check whether a node is an R string
@@ -10,7 +11,18 @@ export interface RString<Info = NoInfo> extends Leaf<Info>, Location {
     content: RStringValue;
 }
 /**
- * Type guard for RString nodes.
- * @see {@link RString}
+ * Helper for working with {@link RString} AST nodes.
  */
-export declare function isRString(node: RNode | undefined): node is RString;
+export declare const RString: {
+    name: string;
+    /**
+     * Type guard for RString nodes.
+     * @see {@link RString}
+     */
+    is<Info = object>(this: void, node: RNode<Info> | undefined): node is RString<Info>;
+    /**
+     * Returns the minimum R version that supports raw strings (in a stable format).
+     * @see {@link RString}
+     */
+    rawStringAvailableFromRVersion(): SemVer;
+};

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

@@ -1,12 +1,27 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.isRString = isRString;
+exports.RString = void 0;
 const type_1 = require("../type");
+const semver_1 = require("semver");
+const versions_1 = require("../versions");
 /**
- * Type guard for RString nodes.
- * @see {@link RString}
+ * Helper for working with {@link RString} AST nodes.
  */
-function isRString(node) {
-    return node?.type === type_1.RType.String;
-}
+exports.RString = {
+    name: 'RString',
+    /**
+     * Type guard for RString nodes.
+     * @see {@link RString}
+     */
+    is(node) {
+        return node?.type === type_1.RType.String;
+    },
+    /**
+     * Returns the minimum R version that supports raw strings (in a stable format).
+     * @see {@link RString}
+     */
+    rawStringAvailableFromRVersion() {
+        return new semver_1.SemVer(versions_1.MIN_VERSION_RAW_STABLE);
+    }
+};
 //# sourceMappingURL=r-string.js.map

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

@@ -1,10 +1,7 @@
-import type { Leaf, Location, NoInfo } from '../model';
-import type { RType } from '../type';
+import type { Leaf, Location, NoInfo, RNode } from '../model';
+import { RType } from '../type';
+import { RNa, RNull } from '../../../convert-values';
 import type { Identifier } from '../../../../../dataflow/environments/identifier';
-/**
- *
- */
-export declare function isSpecialSymbol(symbol: RSymbol): boolean;
 /**
  * Represents identifiers (variables) such as `x` in `x <- 42` or `a::foo` in `a::foo()`.
  * See {@link Identifier} for more information about how identifiers are represented.
@@ -15,3 +12,21 @@ export interface RSymbol<Info = NoInfo, T extends Identifier = Identifier> exten
     readonly type: RType.Symbol;
     content: T;
 }
+/**
+ * Helper for working with {@link RSymbol} AST nodes.
+ */
+export declare const RSymbol: {
+    readonly name: "RSymbol";
+    /**
+     * Type guard for {@link RSymbol} nodes.
+     * @see {@link RSymbol.isSpecial} - to check whether a symbol is a special symbol like `NA` or `NULL`
+     */
+    readonly is: <OtherInfo = object>(this: void, node: RNode<OtherInfo> | undefined) => node is RSymbol<OtherInfo>;
+    /**
+     * Type guard for special symbols, i.e. `NA` and `NULL`.
+     * @see {@link RNa} - for the value of `NA`
+     * @see {@link RNull} - for the value of `NULL`
+     * @see {@link RSymbol.is} - to check whether a node is a symbol at all
+     */
+    readonly isSpecial: <OtherInfo = object>(this: void, node: RNode<OtherInfo> | undefined) => node is RSymbol<OtherInfo, typeof RNull | typeof RNa>;
+};

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

@@ -1,11 +1,28 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.isSpecialSymbol = isSpecialSymbol;
+exports.RSymbol = void 0;
+const type_1 = require("../type");
 const convert_values_1 = require("../../../convert-values");
 /**
- *
+ * Helper for working with {@link RSymbol} AST nodes.
  */
-function isSpecialSymbol(symbol) {
-    return symbol.content === convert_values_1.RNull || symbol.content === convert_values_1.RNa;
-}
+exports.RSymbol = {
+    name: 'RSymbol',
+    /**
+     * Type guard for {@link RSymbol} nodes.
+     * @see {@link RSymbol.isSpecial} - to check whether a symbol is a special symbol like `NA` or `NULL`
+     */
+    is(node) {
+        return node?.type === type_1.RType.Symbol;
+    },
+    /**
+     * Type guard for special symbols, i.e. `NA` and `NULL`.
+     * @see {@link RNa} - for the value of `NA`
+     * @see {@link RNull} - for the value of `NULL`
+     * @see {@link RSymbol.is} - to check whether a node is a symbol at all
+     */
+    isSpecial(node) {
+        return exports.RSymbol.is(node) && (node.content === convert_values_1.RNull || node.content === convert_values_1.RNa);
+    }
+};
 //# sourceMappingURL=r-symbol.js.map

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

@@ -1,5 +1,6 @@
 import type { RAstNodeBase, Location, NoInfo, RNode } from '../model';
-import type { RType } from '../type';
+import { RType } from '../type';
+import type { OperatorInformationValue } from '../operators';
 /**
  * Unary operations like `+` and `-`
  */
@@ -8,3 +9,17 @@ export interface RUnaryOp<Info = NoInfo> extends RAstNodeBase<Info>, Location {
     operator: string;
     operand: RNode<Info>;
 }
+/**
+ * Helper for working with {@link RUnaryOp} AST nodes.
+ */
+export declare const RUnaryOp: {
+    readonly name: "RUnaryOp";
+    /**
+     * Type guard for {@link RUnaryOp} nodes.
+     */
+    readonly is: <Info = object>(this: void, node: RNode<Info> | undefined) => node is RUnaryOp<Info>;
+    /**
+     * Get the operator information for a binary operator node.
+     */
+    readonly getOperatorInfo: <Info = object>(node: RUnaryOp<Info>) => OperatorInformationValue | undefined;
+};

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

@@ -1,3 +1,24 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
+exports.RUnaryOp = void 0;
+const type_1 = require("../type");
+const operators_1 = require("../operators");
+/**
+ * Helper for working with {@link RUnaryOp} AST nodes.
+ */
+exports.RUnaryOp = {
+    name: 'RUnaryOp',
+    /**
+     * Type guard for {@link RUnaryOp} nodes.
+     */
+    is(node) {
+        return node?.type === type_1.RType.UnaryOp;
+    },
+    /**
+     * Get the operator information for a binary operator node.
+     */
+    getOperatorInfo(node) {
+        return operators_1.OperatorDatabase[node.operator];
+    }
+};
 //# sourceMappingURL=r-unary-op.js.map

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

@@ -1,5 +1,5 @@
 import type { RAstNodeBase, Location, NoInfo, RNode } from '../model';
-import type { RType } from '../type';
+import { RType } from '../type';
 import type { RExpressionList } from './r-expression-list';
 /**
  * ```r
@@ -11,3 +11,13 @@ export interface RWhileLoop<Info = NoInfo> extends RAstNodeBase<Info>, Location
     condition: RNode<Info>;
     body: RExpressionList<Info>;
 }
+/**
+ * Helper for working with {@link RWhileLoop} AST nodes.
+ */
+export declare const RWhileLoop: {
+    readonly name: "RWhileLoop";
+    /**
+     * Type guard for {@link RWhileLoop} nodes.
+     */
+    readonly is: <Info = object>(this: void, node: RNode<Info> | undefined) => node is RWhileLoop<Info>;
+};

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

@@ -1,3 +1,17 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
+exports.RWhileLoop = void 0;
+const type_1 = require("../type");
+/**
+ * Helper for working with {@link RWhileLoop} AST nodes.
+ */
+exports.RWhileLoop = {
+    name: 'RWhileLoop',
+    /**
+     * Type guard for {@link RWhileLoop} nodes.
+     */
+    is(node) {
+        return node?.type === type_1.RType.WhileLoop;
+    }
+};
 //# sourceMappingURL=r-while-loop.js.map

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

@@ -4,8 +4,45 @@ import type { DataflowGraph } from '../../../../../dataflow/graph/graph';
 export type NodeId<T extends string | number = string | number> = T & {
     __brand?: 'node-id';
 };
-/** used so that we do not have to store strings for the default numeric ids */
-export declare function normalizeIdToNumberIfPossible(id: NodeId): NodeId;
+/**
+ * A variant of {@link NodeId} that represents built-in functions or operators. The string is prefixed with `built-in:` to avoid confusion with other node ids.
+ */
+export type BuiltIn<T extends string = string> = `built-in:${T}`;
+/**
+ * The type of the id assigned to each node. Branded to avoid problematic usages with other string or numeric types.
+ * The default ids are numeric, but we use a branded type to avoid confusion with other numeric types.
+ * Custom ids or scoped ids can be strings, but they will be normalized to numbers if they are numeric strings.
+ */
+export declare const NodeId: {
+    readonly name: "NodeId";
+    /**
+     * Normalizes a node id by converting numeric strings to numbers.
+     * This allows us to use numeric ids without storing them as strings, while still allowing custom string ids if needed.
+     */
+    readonly normalize: (this: void, id: NodeId) => NodeId;
+    /**
+     * The prefix used for built-in function or operator ids.
+     */
+    readonly builtInPrefix: "built-in:";
+    /**
+     * Checks if a given node id is a built-in function or operator id by checking if it is a string that starts with the built-in prefix.
+     * @see {@link toBuiltIn} - to convert a built-in function or operator name to a built-in id
+     * @see {@link fromBuiltIn} - to recover the built-in function or operator name from a built-in id
+     */
+    readonly isBuiltIn: (this: void, id: BuiltIn | NodeId | undefined) => id is BuiltIn;
+    /**
+     * Converts a built-in function or operator name to a built-in id by prefixing it with the built-in prefix.
+     * @see {@link isBuiltIn} - to check if a given node id is a built-in function or operator id
+     * @see {@link fromBuiltIn} - to recover the built-in function or operator name from a built-in id
+     */
+    readonly toBuiltIn: <T extends string>(this: void, name: T) => BuiltIn<T>;
+    /**
+     * Recovers the built-in function or operator name from a built-in id by removing the built-in prefix.
+     * @see {@link isBuiltIn} - to check if a given node id is a built-in function or operator id
+     * @see {@link toBuiltIn} - to convert a built-in function or operator name to a built-in id
+     */
+    readonly fromBuiltIn: <T extends string>(this: void, id: BuiltIn<T>) => T;
+};
 /**
  * Recovers the lexeme of a {@link RNode|node} from its id in the {@link AstIdMap|id map}.
  * @see {@link recoverContent} - to recover the content of a node

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

@@ -1,20 +1,63 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.normalizeIdToNumberIfPossible = normalizeIdToNumberIfPossible;
+exports.NodeId = void 0;
 exports.recoverName = recoverName;
 exports.recoverContent = recoverContent;
 const vertex_1 = require("../../../../../dataflow/graph/vertex");
 const retriever_1 = require("../../../../retriever");
 const identifier_1 = require("../../../../../dataflow/environments/identifier");
-const numIdRegex = /^\d+$/;
-/** used so that we do not have to store strings for the default numeric ids */
-function normalizeIdToNumberIfPossible(id) {
-    // check if string is number
-    if (typeof id === 'string' && numIdRegex.test(id)) {
-        return Number(id);
+/**
+ * The type of the id assigned to each node. Branded to avoid problematic usages with other string or numeric types.
+ * The default ids are numeric, but we use a branded type to avoid confusion with other numeric types.
+ * Custom ids or scoped ids can be strings, but they will be normalized to numbers if they are numeric strings.
+ */
+exports.NodeId = {
+    name: 'NodeId',
+    /**
+     * Normalizes a node id by converting numeric strings to numbers.
+     * This allows us to use numeric ids without storing them as strings, while still allowing custom string ids if needed.
+     */
+    normalize(id) {
+        // check if string is number
+        if (typeof id === 'string') {
+            /* typescript is a beautiful converter */
+            const num = +id;
+            if (!Number.isNaN(num)) {
+                return num;
+            }
+        }
+        return id;
+    },
+    /**
+     * The prefix used for built-in function or operator ids.
+     */
+    builtInPrefix: 'built-in:',
+    /**
+     * Checks if a given node id is a built-in function or operator id by checking if it is a string that starts with the built-in prefix.
+     * @see {@link toBuiltIn} - to convert a built-in function or operator name to a built-in id
+     * @see {@link fromBuiltIn} - to recover the built-in function or operator name from a built-in id
+     */
+    isBuiltIn(id) {
+        return typeof id === 'string' && id.startsWith(exports.NodeId.builtInPrefix);
+    },
+    /**
+     * Converts a built-in function or operator name to a built-in id by prefixing it with the built-in prefix.
+     * @see {@link isBuiltIn} - to check if a given node id is a built-in function or operator id
+     * @see {@link fromBuiltIn} - to recover the built-in function or operator name from a built-in id
+     */
+    toBuiltIn(name) {
+        return `built-in:${name}`;
+    },
+    /**
+     * Recovers the built-in function or operator name from a built-in id by removing the built-in prefix.
+     * @see {@link isBuiltIn} - to check if a given node id is a built-in function or operator id
+     * @see {@link toBuiltIn} - to convert a built-in function or operator name to a built-in id
+     */
+    fromBuiltIn(id) {
+        return id.slice(builtInPrefixLength);
     }
-    return id;
-}
+};
+const builtInPrefixLength = exports.NodeId.builtInPrefix.length;
 /**
  * Recovers the lexeme of a {@link RNode|node} from its id in the {@link AstIdMap|id map}.
  * @see {@link recoverContent} - to recover the content of a node

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

@@ -1,12 +1,13 @@
 import type { NoInfo, RNode } from '../model';
+import type { EmptyArgument } from '../nodes/r-function-call';
 /** Return `true` to stop visiting from this node (i.e., do not continue to visit this node *and* the children) */
 export type OnEnter<OtherInfo> = (node: RNode<OtherInfo>) => (boolean | void);
 /** Similar to {@link OnEnter} but called when leaving a node. Can't stop exploration as the subtree is already visited! */
 export type OnExit<OtherInfo> = (node: RNode<OtherInfo>) => void;
-/**
- * Visits all node ids within a tree given by a respective root node using a depth-first search with prefix order.
- * @param nodes          - The root id nodes to start collecting from
- * @param onVisit        - Called before visiting the subtree of each node. Can be used to stop visiting the subtree starting with this node (return `true` stop)
- * @param onExit         - Called after the subtree of a node has been visited, called for leafs too (even though their subtree is empty)
- */
-export declare function visitAst<OtherInfo = NoInfo>(nodes: RNode<OtherInfo> | (RNode<OtherInfo> | null | undefined)[] | undefined, onVisit?: OnEnter<OtherInfo>, onExit?: OnExit<OtherInfo>): void;
+export declare class NodeVisitor<OtherInfo = NoInfo> {
+    private readonly onEnter?;
+    private readonly onExit?;
+    constructor(onEnter?: OnEnter<OtherInfo>, onExit?: OnExit<OtherInfo>);
+    private visitSingle;
+    visit(nodes: RNode<OtherInfo> | readonly (RNode<OtherInfo> | null | undefined | typeof EmptyArgument)[] | undefined | null): void;
+}

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

@@ -1,9 +1,10 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.visitAst = visitAst;
+exports.NodeVisitor = void 0;
 const type_1 = require("../type");
 const assert_1 = require("../../../../../util/assert");
-const r_function_call_1 = require("../nodes/r-function-call");
+const r_access_1 = require("../nodes/r-access");
+const graph_1 = require("../../../../../dataflow/graph/graph");
 // capsuled as a class to avoid passing onExit and onEnter on *each* visit call
 class NodeVisitor {
     onEnter;
@@ -66,7 +67,7 @@ class NodeVisitor {
                 break;
             case type_1.RType.Access:
                 this.visitSingle(node.accessed);
-                if (node.operator === '[' || node.operator === '[[') {
+                if (r_access_1.RAccess.isIndex(node)) {
                     this.visit(node.access);
                 }
                 break;
@@ -89,7 +90,7 @@ class NodeVisitor {
         if (Array.isArray(nodes)) {
             const n = nodes;
             for (const node of n) {
-                if (node && node !== r_function_call_1.EmptyArgument) {
+                if (node && graph_1.FunctionArgument.isNotEmpty(node)) {
                     this.visitSingle(node);
                 }
             }
@@ -99,13 +100,5 @@ class NodeVisitor {
         }
     }
 }
-/**
- * Visits all node ids within a tree given by a respective root node using a depth-first search with prefix order.
- * @param nodes          - The root id nodes to start collecting from
- * @param onVisit        - Called before visiting the subtree of each node. Can be used to stop visiting the subtree starting with this node (return `true` stop)
- * @param onExit         - Called after the subtree of a node has been visited, called for leafs too (even though their subtree is empty)
- */
-function visitAst(nodes, onVisit, onExit) {
-    return new NodeVisitor(onVisit, onExit).visit(nodes);
-}
+exports.NodeVisitor = NodeVisitor;
 //# sourceMappingURL=visitor.js.map

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

@@ -3,7 +3,7 @@ import type { NoInfo } from '../../model/model';
 import type { ParseStepOutput, ParseStepOutputSingleFile } from '../../../../parser';
 import { type FlowrConfigOptions } from '../../../../../config';
 import type { Tree } from 'web-tree-sitter';
-import type { RProject } from '../../model/nodes/r-project';
+import { RProject } from '../../model/nodes/r-project';
 export declare const parseLog: import("tslog").Logger<import("tslog").ILogObj>;
 /**
  * Take the output as produced by the parse step and normalize the AST from the R parser.

package/r-bridge/lang-4.x/ast/parser/json/parser.js

@@ -18,7 +18,7 @@ exports.parseLog = log_1.log.getSubLogger({ name: 'ast-parser' });
  * @see {@link normalizeTreeSitter}      - for a version that normalizes the AST from the TreeSitter parser
  */
 function normalize(parsed, getId = (0, decorate_1.deterministicCountingIdGenerator)(0)) {
-    return (0, decorate_1.decorateAst)((0, r_project_1.mergeProjects)(parsed.files.map(normalizeButNotDecorated)), { getId });
+    return (0, decorate_1.decorateAst)(r_project_1.RProject.merge(parsed.files.map(normalizeButNotDecorated)), { getId });
 }
 /**
  * Take the output as produced by the parse step and normalize the AST from the R parser.

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

@@ -9,6 +9,8 @@ const normalize_call_1 = require("../functions/normalize-call");
 const normalize_definition_1 = require("../functions/normalize-definition");
 const type_1 = require("../../../../model/type");
 const normalize_comment_1 = require("../other/normalize-comment");
+const r_delimiter_1 = require("../../../../model/nodes/info/r-delimiter");
+const r_comment_1 = require("../../../../model/nodes/r-comment");
 /**
  * Returns an expression list if there are multiple children, otherwise returns the single child directly with no expr wrapper
  * @param data - The data used by the parser (see {@link NormalizerData})
@@ -36,10 +38,10 @@ function normalizeExpression(data, entry) {
         return maybeFunctionDefinition;
     }
     const children = (0, normalize_expressions_1.normalizeExpressions)(childData, childrenSource);
-    const [delimiters, nodes] = (0, arrays_1.partition)(children, x => x.type === type_1.RType.Delimiter || x.type === type_1.RType.Comment);
+    const [delimiters, nodes] = (0, arrays_1.partition)(children, x => r_delimiter_1.RDelimiter.is(x) || r_comment_1.RComment.is(x));
     if (nodes.length === 1) {
         const result = nodes[0];
-        result.info.adToks = [...result.info.adToks ?? [], ...delimiters];
+        result.info.adToks = result.info.adToks ? result.info.adToks.concat(delimiters) : delimiters.slice();
         return result;
     }
     else {

package/r-bridge/lang-4.x/ast/parser/main/internal/values/normalize-number.js

@@ -41,7 +41,7 @@ function normalizeNumber(data, obj) {
         return {
             ...common,
             type: type_1.RType.Number,
-            content: (0, convert_values_1.number2ts)(content)
+            content: convert_values_1.RNumberValue.fromRLexeme(content)
         };
     }
 }

package/r-bridge/lang-4.x/ast/parser/main/internal/values/normalize-string.js

@@ -3,8 +3,8 @@ Object.defineProperty(exports, "__esModule", { value: true });
 exports.normalizeString = normalizeString;
 const normalize_meta_1 = require("../../normalize-meta");
 const assert_1 = require("../../../../../../../util/assert");
-const convert_values_1 = require("../../../../../convert-values");
 const type_1 = require("../../../../model/type");
+const convert_values_1 = require("../../../../../convert-values");
 /**
  * Normalize the given object as a R string (see {@link string2ts}).
  * This requires you to check the corresponding name beforehand.
@@ -23,7 +23,7 @@ function normalizeString(data, obj) {
     return {
         type: type_1.RType.String,
         location,
-        content: (0, convert_values_1.string2ts)(stringContent),
+        content: convert_values_1.RStringValue.fromRLexeme(stringContent),
         lexeme: stringContent,
         info: {
             fullRange: data.currentRange,

package/r-bridge/lang-4.x/convert-values.d.ts

@@ -30,10 +30,13 @@ export interface RNumberValue {
     /** see {@link RImaginaryMarker}, compound imaginary numbers are expressions in R */
     complexNumber: boolean;
 }
+export declare const RNumberValue: {
+    readonly name: "RNumberValue";
+    readonly fromRLexeme: (this: void, value: string) => RNumberValue;
+};
 /**
- * Convert a valid R number into a {@link RNumberValue}.
+ * Represents a string value in R, including the type of quotes used and whether it is a raw string.
  */
-export declare function number2ts(value: string): RNumberValue;
 export interface RStringValue {
     str: string;
     /** from the R-language definition a string is either delimited by a pair of single or double quotes, 'none' strings are syntactically unquoted but treated as strings  */
@@ -42,10 +45,16 @@ export interface RStringValue {
     flag?: 'raw';
 }
 /**
- * Convert a valid R string into a {@link RStringValue}.
- * @throws {@link ValueConversionError} if the string has an unknown starting quote
+ * Checks whether the given string is an R string literal (including raw strings).
  */
-export declare function string2ts(value: string): RStringValue;
+export declare const RStringValue: {
+    readonly name: "RStringValue";
+    /**
+     * Convert a valid R string into a {@link RStringValue}.
+     * @throws {@link ValueConversionError} if the string has an unknown starting quote
+     */
+    readonly fromRLexeme: (this: void, value: string) => RStringValue;
+};
 export declare const RNa = "NA";
 export declare const RNull = "NULL";
 /**