@eagleoutice/flowr 1.5.2 → 2.0.0

package/r-bridge/lang-4.x/{values.js → convert-values.js}

@@ -11,10 +11,7 @@ class ValueConversionError extends Error {
  * transforms a value to something R can understand (e.g., booleans to TRUE/FALSE)
  */
 function ts2r(value) {
-    if (typeof value === 'undefined') {
-        return 'NA';
-    }
-    else if (typeof value === 'string') {
+    if (typeof value === 'string') {
         return JSON.stringify(value);
     }
     else if (typeof value === 'number') {
@@ -32,6 +29,9 @@ function ts2r(value) {
     else if (value === null) {
         return 'NULL';
     }
+    else if (typeof value === 'undefined') {
+        return 'NA';
+    }
     else if (Array.isArray(value)) {
         return `c(${value.map(ts2r).join(', ')})`;
     }
@@ -154,4 +154,4 @@ function isNA(value) {
     return value === exports.RNa;
 }
 exports.isNA = isNA;
-//# sourceMappingURL=values.js.map
+//# sourceMappingURL=convert-values.js.map

package/r-bridge/retriever.d.ts

@@ -1,11 +1,11 @@
 import { type RShell } from './shell';
-import type { XmlParserHooks, NormalizedAst } from './lang-4.x';
-import type { AsyncOrSync, DeepPartial } from 'ts-essentials';
+import type { AsyncOrSync } from 'ts-essentials';
 import { RShellExecutor } from './shell-executor';
-export declare const fileProtocol: "file://";
+import type { NormalizedAst } from './lang-4.x/ast/model/processing/decorate';
+export declare const fileProtocol = "file://";
 export interface RParseRequestFromFile {
     readonly request: 'file';
-    /** The path to the file (absolute paths are probably best here */
+    /** The path to the file (absolute paths are probably best here) */
     readonly content: string;
 }
 export interface RParseRequestFromText {
@@ -41,7 +41,7 @@ export declare function retrieveParseDataFromRCode(request: RParseRequest, shell
  * Uses {@link retrieveParseDataFromRCode} and returns the nicely formatted object-AST.
  * If successful, allows to further query the last result with {@link retrieveNumberOfRTokensOfLastParse}.
  */
-export declare function retrieveNormalizedAstFromRCode(request: RParseRequest, shell: RShell, hooks?: DeepPartial<XmlParserHooks>): Promise<NormalizedAst>;
+export declare function retrieveNormalizedAstFromRCode(request: RParseRequest, shell: RShell): Promise<NormalizedAst>;
 /**
  * If the string has (R-)quotes around it, they will be removed, otherwise the string is returned unchanged.
  */

package/r-bridge/retriever.js

@@ -4,12 +4,13 @@ var __importDefault = (this && this.__importDefault) || function (mod) {
 };
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.retrieveNumberOfRTokensOfLastParse = exports.removeRQuotes = exports.retrieveNormalizedAstFromRCode = exports.retrieveParseDataFromRCode = exports.requestFingerprint = exports.requestProviderFromText = exports.requestProviderFromFile = exports.requestFromInput = exports.fileProtocol = void 0;
-const lang_4_x_1 = require("./lang-4.x");
 const strings_1 = require("../util/strings");
 const assert_1 = require("../util/assert");
 const shell_executor_1 = require("./shell-executor");
 const object_hash_1 = __importDefault(require("object-hash"));
 const parser_1 = require("./lang-4.x/ast/parser/json/parser");
+const init_1 = require("./init");
+const convert_values_1 = require("./lang-4.x/convert-values");
 exports.fileProtocol = 'file://';
 /**
  * Creates a {@link RParseRequest} from a given input.
@@ -48,7 +49,6 @@ function requestFingerprint(request) {
     return (0, object_hash_1.default)(request);
 }
 exports.requestFingerprint = requestFingerprint;
-const ErrorMarker = 'err';
 /**
  * Provides the capability to parse R files/R code using the R parser.
  * Depends on {@link RShell} to provide a connection to R.
@@ -57,25 +57,12 @@ const ErrorMarker = 'err';
  * If successful, allows to further query the last result with {@link retrieveNumberOfRTokensOfLastParse}.
  */
 function retrieveParseDataFromRCode(request, shell) {
+    if (request.content.trim() === '') {
+        return Promise.resolve('');
+    }
     const suffix = request.request === 'file' ? ', encoding="utf-8"' : '';
-    const eol = (0, lang_4_x_1.ts2r)(shell.options.eol);
-    const command = 
-    /* first check if flowr_get is already part of the environment */
-    'if(!exists("flowr_get")){'
-        /* if not, define it complete wrapped in a try so that we can handle failures gracefully on stdout */
-        + 'flowr_get<-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<<-utils::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(apply(flowr_output,1,function(o)sprintf("[%s,%s,%s,%s,%s,%s,%s,%s,%s]",o[[1]],o[[2]],o[[3]],o[[4]],o[[5]],o[[6]],deparse(o[[7]]),if(o[[8]])"true"else"false",deparse(o[[9]]))),collapse=","),"]",${eol},sep="")`
-        /* error handling (just produce the marker) */
-        + `},error=function(e){cat("${ErrorMarker}",${eol})})};`
-        /* compile the function to improve perf. */
-        + 'flowr_get<-compiler::cmpfun(flowr_get)};'
-        /* call the function with the request */
-        + `flowr_get(${request.request}=${JSON.stringify(request.content)}${suffix})`;
+    /* call the function with the request */
+    const command = `flowr_get_ast(${request.request}=${JSON.stringify(request.content)}${suffix})`;
     if (shell instanceof shell_executor_1.RShellExecutor) {
         return guardRetrievedOutput(shell.run(command), request);
     }
@@ -88,9 +75,9 @@ exports.retrieveParseDataFromRCode = retrieveParseDataFromRCode;
  * Uses {@link retrieveParseDataFromRCode} and returns the nicely formatted object-AST.
  * If successful, allows to further query the last result with {@link retrieveNumberOfRTokensOfLastParse}.
  */
-async function retrieveNormalizedAstFromRCode(request, shell, hooks) {
+async function retrieveNormalizedAstFromRCode(request, shell) {
     const data = await retrieveParseDataFromRCode(request, shell);
-    return (0, parser_1.normalize)(data, hooks);
+    return (0, parser_1.normalize)(data);
 }
 exports.retrieveNormalizedAstFromRCode = retrieveNormalizedAstFromRCode;
 /**
@@ -109,13 +96,13 @@ exports.removeRQuotes = removeRQuotes;
  * Needs to be called *after*  {@link retrieveParseDataFromRCode} (or {@link retrieveNormalizedAstFromRCode})
  */
 async function retrieveNumberOfRTokensOfLastParse(shell) {
-    const result = await shell.sendCommandWithOutput(`cat(nrow(flowr_output),${(0, lang_4_x_1.ts2r)(shell.options.eol)})`);
+    const result = await shell.sendCommandWithOutput(`cat(nrow(flowr_output),${(0, convert_values_1.ts2r)(shell.options.eol)})`);
     (0, assert_1.guard)(result.length === 1, () => `expected exactly one line to obtain the number of R tokens, but got: ${JSON.stringify(result)}`);
     return Number(result[0]);
 }
 exports.retrieveNumberOfRTokensOfLastParse = retrieveNumberOfRTokensOfLastParse;
 function guardRetrievedOutput(output, request) {
-    (0, assert_1.guard)(output !== ErrorMarker, () => `unable to parse R code (see the log for more information) for request ${JSON.stringify(request)}}`);
+    (0, assert_1.guard)(output !== init_1.ErrorMarker, () => `unable to parse R code (see the log for more information) for request ${JSON.stringify(request)}}`);
     return output;
 }
 //# sourceMappingURL=retriever.js.map

package/r-bridge/shell-executor.d.ts

@@ -4,7 +4,6 @@ export declare class RShellExecutor {
     readonly options: Readonly<RShellExecutionOptions>;
     private readonly prerequisites;
     constructor(options?: Partial<RShellExecutionOptions>);
-    continueOnError(): this;
     addPrerequisites(commands: string | string[]): this;
     usedRVersion(): SemVer | null;
     run(command: string, returnErr?: boolean): string;

package/r-bridge/shell-executor.js

@@ -7,35 +7,30 @@ exports.RShellExecutor = void 0;
 const shell_1 = require("./shell");
 const objects_1 = require("../util/objects");
 const child_process_1 = require("child_process");
-const lang_4_x_1 = require("./lang-4.x");
 const preload_1 = __importDefault(require("semver/preload"));
 const log_1 = require("../util/log");
+const init_1 = require("./init");
+const convert_values_1 = require("./lang-4.x/convert-values");
 const executorLog = log_1.log.getSubLogger({ name: 'RShellExecutor' });
 class RShellExecutor {
     options;
-    prerequisites = [];
+    prerequisites;
     constructor(options) {
         this.options = (0, objects_1.deepMergeObject)(shell_1.DEFAULT_R_SHELL_OPTIONS, options);
-    }
-    continueOnError() {
-        executorLog.info('continue in case of Errors');
-        this.addPrerequisites('options(error=function() {})');
-        return this;
+        this.prerequisites = [(0, init_1.initCommand)(this.options.eol)];
     }
     addPrerequisites(commands) {
         this.prerequisites.push(...(typeof commands == 'string' ? [commands] : commands));
         return this;
     }
     usedRVersion() {
-        const version = this.run(`cat(paste0(R.version$major,".",R.version$minor), ${(0, lang_4_x_1.ts2r)(this.options.eol)})`);
-        executorLog.trace(`raw version: ${JSON.stringify(version)}`);
+        const version = this.run(`cat(paste0(R.version$major,".",R.version$minor), ${(0, convert_values_1.ts2r)(this.options.eol)})`);
+        (0, log_1.expensiveTrace)(executorLog, () => `raw version: ${JSON.stringify(version)}`);
         return preload_1.default.coerce(version);
     }
     run(command, returnErr = false) {
         command += ';base::quit()';
-        if (executorLog.settings.minLevel >= 1 /* LogLevel.Trace */) {
-            executorLog.trace(`> ${JSON.stringify(command)}`);
-        }
+        (0, log_1.expensiveTrace)(executorLog, () => `> ${JSON.stringify(command)}`);
         const returns = (0, child_process_1.spawnSync)(this.options.pathToRExecutable, this.options.commandLineOptions, {
             env: this.options.env,
             cwd: this.options.cwd,

package/r-bridge/shell.d.ts

@@ -1,16 +1,18 @@
 /// <reference types="node" />
 import { type MergeableRecord } from '../util/objects';
 import type { SemVer } from 'semver';
+import type { AsyncOrSync } from 'ts-essentials';
 export type OutputStreamSelector = 'stdout' | 'stderr' | 'both';
 export interface CollectorTimeout extends MergeableRecord {
     /**
    * number of milliseconds to wait for the collection to finish
    */
     ms: number;
-    /**
-   * if true, the timeout will reset whenever we receive new data
-   */
     resetOnNewData: boolean;
+    /**
+     * invoked when the timeout is reached. If not set, the promise will be rejected with an error.
+     */
+    onTimeout?: (resolve: (value: AsyncOrSync<string[]>) => void, reject: (value: AsyncOrSync<string[]>) => void, partialResult: string[]) => void;
 }
 /**
  * Configuration for the internal output collector used by the {@link RShell}
@@ -32,6 +34,11 @@ export interface OutputCollectorConfiguration extends MergeableRecord {
     automaticallyTrimOutput: boolean;
 }
 export declare const DEFAULT_OUTPUT_COLLECTOR_CONFIGURATION: OutputCollectorConfiguration;
+export declare const enum RShellReviveOptions {
+    Never = 0,
+    OnError = 1,
+    Always = 2
+}
 export interface RShellExecutionOptions extends MergeableRecord {
     /** The path to the R executable, can be only the executable if it is to be found on the PATH. */
     readonly pathToRExecutable: string;
@@ -42,13 +49,13 @@ export interface RShellExecutionOptions extends MergeableRecord {
     /** The character to use to mark the end of a line. Is probably always `\n` (even on windows). */
     readonly eol: string;
     /** The environment variables available in the R session. */
-    readonly env: NodeJS.ProcessEnv;
+    readonly env: NodeJS.ProcessEnv | undefined;
     /** The path to the library directory, use undefined to let R figure that out for itself */
     readonly homeLibPath: string | undefined;
 }
 export interface RShellSessionOptions extends RShellExecutionOptions {
     /** If set, the R session will be restarted if it exits due to an error */
-    readonly revive: 'never' | 'on-error' | 'always';
+    readonly revive: RShellReviveOptions;
     /** Called when the R session is restarted, this makes only sense if `revive` is not set to `'never'` */
     readonly onRevive: (code: number, signal: string | null) => void;
 }
@@ -84,7 +91,7 @@ export declare class RShell {
    */
     sendCommand(command: string): void;
     usedRVersion(): Promise<SemVer | null>;
-    injectLibPaths(...paths: string[]): void;
+    injectLibPaths(...paths: readonly string[]): void;
     tryToInjectHomeLibPath(): void;
     /**
      * checks if a given package is already installed on the system!
@@ -103,16 +110,11 @@ export declare class RShell {
    *
    * @see sendCommand
    */
-    sendCommands(...commands: string[]): void;
+    sendCommands(...commands: readonly string[]): void;
     /**
    * clears the R environment using the `rm` command.
    */
     clearEnvironment(): void;
-    /**
-   * usually R will stop execution on errors, with this the R session will try to
-   * continue working!
-   */
-    continueOnError(): void;
     /**
      * Obtain the temporary directory used by R.
      * Additionally, this marks the directory for removal when the shell exits.

package/r-bridge/shell.js

@@ -27,15 +27,16 @@ var __importDefault = (this && this.__importDefault) || function (mod) {
 };
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.RShell = exports.DEFAULT_R_SHELL_OPTIONS = exports.DEFAULT_R_SHELL_EXEC_OPTIONS = exports.DEFAULT_R_PATH = exports.DEFAULT_OUTPUT_COLLECTOR_CONFIGURATION = void 0;
-const child_process_1 = require("child_process");
+const node_child_process_1 = require("node:child_process");
 const objects_1 = require("../util/objects");
 const readline = __importStar(require("readline"));
-const lang_4_x_1 = require("./lang-4.x");
 const log_1 = require("../util/log");
 const preload_1 = __importDefault(require("semver/preload"));
 const os_1 = require("../util/os");
 const fs_1 = __importDefault(require("fs"));
+const init_1 = require("./init");
 const config_1 = require("../config");
+const convert_values_1 = require("./lang-4.x/convert-values");
 exports.DEFAULT_OUTPUT_COLLECTOR_CONFIGURATION = {
     from: 'stdout',
     postamble: `🐧${'-'.repeat(5)}🐧`,
@@ -50,16 +51,16 @@ exports.DEFAULT_OUTPUT_COLLECTOR_CONFIGURATION = {
 exports.DEFAULT_R_PATH = (0, os_1.getPlatform)() === 'windows' ? 'R.exe' : 'R';
 exports.DEFAULT_R_SHELL_EXEC_OPTIONS = {
     pathToRExecutable: (0, config_1.getConfig)().rPath ?? exports.DEFAULT_R_PATH,
-    commandLineOptions: ['--vanilla', '--quiet', '--no-echo', '--no-save'],
+    commandLineOptions: ['--vanilla', '--quiet', '--no-echo', '--no-save', '--slave'],
     cwd: process.cwd(),
-    env: process.env,
+    env: undefined,
     eol: '\n',
     homeLibPath: (0, os_1.getPlatform)() === 'windows' ? undefined : '~/.r-libs'
 };
 exports.DEFAULT_R_SHELL_OPTIONS = {
     ...exports.DEFAULT_R_SHELL_EXEC_OPTIONS,
     sessionName: 'default',
-    revive: 'never',
+    revive: 0 /* RShellReviveOptions.Never */,
     onRevive: () => { }
 };
 /**
@@ -78,17 +79,17 @@ class RShell {
     // should never be more than one, but let's be sure
     tempDirs = new Set();
     constructor(options) {
-        this.options = (0, objects_1.deepMergeObject)(exports.DEFAULT_R_SHELL_OPTIONS, options);
+        this.options = { ...exports.DEFAULT_R_SHELL_OPTIONS, ...options };
         this.log = log_1.log.getSubLogger({ name: this.options.sessionName });
         this.session = new RShellSession(this.options, this.log);
         this.revive();
     }
     revive() {
-        if (this.options.revive === 'never') {
+        if (this.options.revive === 0 /* RShellReviveOptions.Never */) {
             return;
         }
         this.session.onExit((code, signal) => {
-            if (this.options.revive === 'always' || (this.options.revive === 'on-error' && code !== 0)) {
+            if (this.options.revive === 2 /* RShellReviveOptions.Always */ || (this.options.revive === 1 /* RShellReviveOptions.OnError */ && code !== 0)) {
                 this.log.warn(`R session exited with code ${code}, reviving!`);
                 this.options.onRevive(code, signal);
                 this.session = new RShellSession(this.options, this.log);
@@ -101,7 +102,7 @@ class RShell {
    * will not do anything to alter input markers!
    */
     sendCommand(command) {
-        if (this.log.settings.minLevel >= 1 /* LogLevel.Trace */) {
+        if (this.log.settings.minLevel <= 1 /* LogLevel.Trace */) {
             this.log.trace(`> ${JSON.stringify(command)}`);
         }
         this._sendCommand(command);
@@ -111,14 +112,26 @@ class RShell {
             return this.versionCache;
         }
         // retrieve raw version:
-        const result = await this.sendCommandWithOutput(`cat(paste0(R.version$major,".",R.version$minor), ${(0, lang_4_x_1.ts2r)(this.options.eol)})`);
-        this.log.trace(`raw version: ${JSON.stringify(result)}`);
-        this.versionCache = preload_1.default.coerce(result[0]);
-        return result.length === 1 ? this.versionCache : null;
+        const result = await this.sendCommandWithOutput(`cat(paste0(R.version$major,".",R.version$minor), ${(0, convert_values_1.ts2r)(this.options.eol)})`, {
+            timeout: {
+                ms: 5000,
+                resetOnNewData: false,
+                // just resolve on timeout and handle the empty array case below
+                onTimeout: resolve => resolve([])
+            }
+        });
+        (0, log_1.expensiveTrace)(this.log, () => `raw version: ${JSON.stringify(result)}`);
+        if (result.length === 1) {
+            this.versionCache = preload_1.default.coerce(result[0]);
+            return this.versionCache;
+        }
+        else {
+            return null;
+        }
     }
     injectLibPaths(...paths) {
-        this.log.debug(`injecting lib paths ${JSON.stringify(paths)}`);
-        this._sendCommand(`.libPaths(c(.libPaths(), ${paths.map(lang_4_x_1.ts2r).join(',')}))`);
+        (0, log_1.expensiveTrace)(this.log, () => `injecting lib paths ${JSON.stringify(paths)}`);
+        this._sendCommand(`.libPaths(c(.libPaths(), ${paths.map(convert_values_1.ts2r).join(',')}))`);
     }
     tryToInjectHomeLibPath() {
         // ensure the path exists first
@@ -148,16 +161,14 @@ class RShell {
    */
     async sendCommandWithOutput(command, addonConfig) {
         const config = (0, objects_1.deepMergeObject)(exports.DEFAULT_OUTPUT_COLLECTOR_CONFIGURATION, addonConfig);
-        if (this.log.settings.minLevel >= 1 /* LogLevel.Trace */) {
-            this.log.trace(`> ${JSON.stringify(command)}`);
-        }
+        (0, log_1.expensiveTrace)(this.log, () => `> ${JSON.stringify(command)}`);
         const output = await this.session.collectLinesUntil(config.from, {
             predicate: data => data === config.postamble,
             includeInResult: config.keepPostamble // we do not want the postamble
         }, config.timeout, () => {
             this._sendCommand(command);
             if (config.from === 'stderr') {
-                this._sendCommand(`cat("${config.postamble}${this.options.eol}", file=stderr())`);
+                this._sendCommand(`cat("${config.postamble}${this.options.eol}",file=stderr())`);
             }
             else {
                 this._sendCommand(`cat("${config.postamble}${this.options.eol}")`);
@@ -187,21 +198,13 @@ class RShell {
         this.log.debug('clearing environment');
         this._sendCommand('rm(list=ls())');
     }
-    /**
-   * usually R will stop execution on errors, with this the R session will try to
-   * continue working!
-   */
-    continueOnError() {
-        this.log.info('continue in case of Errors');
-        this._sendCommand('options(error=function() {})');
-    }
     /**
      * Obtain the temporary directory used by R.
      * Additionally, this marks the directory for removal when the shell exits.
      */
     async obtainTmpDir() {
-        this.sendCommand('temp <- tempdir()');
-        const [tempdir] = await this.sendCommandWithOutput(`cat(temp, ${(0, lang_4_x_1.ts2r)(this.options.eol)})`);
+        this.sendCommand('temp<-tempdir()');
+        const [tempdir] = await this.sendCommandWithOutput(`cat(temp,${(0, convert_values_1.ts2r)(this.options.eol)})`);
         this.tempDirs.add(tempdir);
         return tempdir;
     }
@@ -226,10 +229,9 @@ class RShellSession {
     sessionStdOut;
     sessionStdErr;
     options;
-    log;
     collectionTimeout;
     constructor(options, log) {
-        this.bareSession = (0, child_process_1.spawn)(options.pathToRExecutable, options.commandLineOptions, {
+        this.bareSession = (0, node_child_process_1.spawn)(options.pathToRExecutable, options.commandLineOptions, {
             env: options.env,
             cwd: options.cwd,
             windowsHide: true
@@ -246,8 +248,19 @@ class RShellSession {
             this.end();
         });
         this.options = options;
-        this.log = log;
-        this.setupRSessionLoggers();
+        // initialize the session
+        this.writeLine((0, init_1.initCommand)(options.eol));
+        if (log.settings.minLevel <= 1 /* LogLevel.Trace */) {
+            this.bareSession.stdout.on('data', (data) => {
+                log.trace(`< ${data.toString()}`);
+            });
+            this.bareSession.on('close', (code) => {
+                log.trace(`session exited with code ${code}`);
+            });
+        }
+        this.bareSession.stderr.on('data', (data) => {
+            log.warn(`< ${data}`);
+        });
     }
     write(data) {
         this.bareSession.stdin.write(data);
@@ -271,7 +284,12 @@ class RShellSession {
         let error;
         return await new Promise((resolve, reject) => {
             const makeTimer = () => setTimeout(() => {
-                reject(new Error(`timeout of ${timeout.ms}ms reached (${JSON.stringify(result)})`));
+                if (timeout.onTimeout) {
+                    timeout.onTimeout(resolve, reject, result);
+                }
+                else {
+                    reject(new Error(`timeout of ${timeout.ms}ms reached (${JSON.stringify(result)})`));
+                }
             }, timeout.ms);
             this.collectionTimeout = makeTimer();
             handler = (data) => {
@@ -324,19 +342,6 @@ class RShellSession {
         log_1.log.info(`killed R session with pid ${this.bareSession.pid ?? '<unknown>'} and result ${killResult ? 'successful' : 'failed'} (including streams)`);
         return killResult;
     }
-    setupRSessionLoggers() {
-        if (this.log.settings.minLevel >= 1 /* LogLevel.Trace */) {
-            this.bareSession.stdout.on('data', (data) => {
-                this.log.trace(`< ${data.toString()}`);
-            });
-            this.bareSession.on('close', (code) => {
-                this.log.trace(`session exited with code ${code}`);
-            });
-        }
-        this.bareSession.stderr.on('data', (data) => {
-            this.log.warn(`< ${data}`);
-        });
-    }
     onExit(callback) {
         this.bareSession.on('exit', callback);
         this.bareSession.stdin.on('error', callback);

package/reconstruct/reconstruct.d.ts

@@ -3,8 +3,10 @@
  * as the file itself is way too long). See {@link reconstructToCode}.
  * @module
  */
-import type { NormalizedAst, NodeId, ParentInformation, RNode } from '../r-bridge';
-type Selection = Set<NodeId>;
+import type { NormalizedAst, ParentInformation } from '../r-bridge/lang-4.x/ast/model/processing/decorate';
+import type { RNode } from '../r-bridge/lang-4.x/ast/model/model';
+import type { NodeId } from '../r-bridge/lang-4.x/ast/model/processing/node-id';
+type Selection = ReadonlySet<NodeId>;
 export declare const reconstructLogger: import("tslog").Logger<import("tslog").ILogObj>;
 /** The structure of the predicate that should be used to determine if a given normalized node should be included in the reconstructed code independent of if it is selected by the slice or not */
 export type AutoSelectPredicate = (node: RNode<ParentInformation>) => boolean;