@r-universe/webr 2023.6.11 → 2023.6.21

package/dist/webR/chan/task-common.d.ts

@@ -0,0 +1,17 @@
+export declare const SZ_BUF_DOESNT_FIT = 0;
+export declare const SZ_BUF_FITS_IDX = 1;
+export declare const SZ_BUF_SIZE_IDX = 0;
+export interface Endpoint extends EventSource {
+    postMessage(message: any, transfer?: Transferable[]): void;
+    start?: () => void;
+}
+export interface EventSource {
+    addEventListener(type: string, listener: EventListenerOrEventListenerObject, options?: {}): void;
+    removeEventListener(type: string, listener: EventListenerOrEventListenerObject, options?: {}): void;
+}
+export declare function toWireValue(value: any): [any, Transferable[]];
+export declare function transfer<T>(obj: T, transfers: Transferable[]): T;
+export type UUID = string;
+export declare function isUUID(x: any): x is UUID;
+export declare const UUID_LENGTH = 63;
+export declare function generateUUID(): UUID;

package/dist/webR/chan/task-main.d.ts

@@ -0,0 +1,15 @@
+import { Endpoint } from './task-common';
+import { SyncRequestData } from './message';
+/**
+ * Respond to a blocking request. Most of the work has already been done in
+ * asynclink, we are just responsible here for getting the return value back to
+ * the requester through this slightly convoluted Atomics protocol.
+ * @param {Endpoint} endpoint  A message port to receive messages from. Other
+ *        thread is blocked, so we can't send messages back.
+ * @param {SyncRequestData} data The message that was recieved. We will use it
+ *        to read out the buffers to write the answer into. NOTE: requester
+ *        owns buffers.
+ * @param {any} response The value we want to send back to the requester. We
+ *        have to encode it into data_buffer.
+ */
+export declare function syncResponse(endpoint: Endpoint, data: SyncRequestData, response: any): Promise<void>;

package/dist/webR/chan/task-worker.d.ts

@@ -0,0 +1,42 @@
+import { Endpoint } from './task-common';
+import { Message } from './message';
+export declare class SyncTask {
+    #private;
+    endpoint: Endpoint;
+    msg: Message;
+    transfers: Transferable[];
+    taskId?: number;
+    sizeBuffer?: Int32Array;
+    signalBuffer?: Int32Array;
+    syncifier: _Syncifier;
+    constructor(endpoint: Endpoint, msg: Message, transfers?: Transferable[]);
+    scheduleSync(): this | undefined;
+    poll(): boolean;
+    doSync(): Generator<undefined, unknown, unknown>;
+    get result(): unknown;
+    syncify(): any;
+}
+declare class _Syncifier {
+    nextTaskId: Int32Array;
+    signalBuffer: Int32Array;
+    tasks: Map<number, SyncTask>;
+    constructor();
+    scheduleTask(task: SyncTask): void;
+    waitOnSignalBuffer(): void;
+    tasksIdsToWakeup(): Generator<number, void, unknown>;
+    pollTasks(task?: SyncTask): boolean;
+    syncifyTask(task: SyncTask): void;
+}
+/**
+ * Sets the interrupt handler. This is called when the computation is
+ * interrupted. Should zero the interrupt buffer and throw an exception.
+ * @internal
+ */
+export declare function setInterruptHandler(handler: () => void): void;
+/**
+ * Sets the interrupt buffer. Should be a shared array buffer. When element 0
+ * is set non-zero it signals an interrupt.
+ * @internal
+ */
+export declare function setInterruptBuffer(buffer: ArrayBufferLike): void;
+export {};

package/dist/webR/compat.d.ts

@@ -0,0 +1,2 @@
+export declare const IN_NODE: boolean;
+export declare let loadScript: (url: string) => Promise<void>;

package/dist/webR/config.d.ts

@@ -0,0 +1,2 @@
+export declare const BASE_URL: string;
+export declare const PKG_BASE_URL = "https://repo.r-wasm.org";

package/dist/webR/console.d.ts

@@ -0,0 +1,68 @@
+import { WebR, WebROptions } from './webr-main';
+export interface ConsoleCallbacks {
+    stdout?: (line: string) => void;
+    stderr?: (line: string) => void;
+    prompt?: (line: string) => void;
+    canvasExec?: (line: string) => void;
+}
+/**
+ * Text-based Interactive Console for WebR
+ *
+ * A helper application to assist in creating an interactive R REPL based on
+ * JavaScript callbacks.
+ *
+ * Callback functions ``stdout`` and ``stderr`` are called with a single line
+ * of output as the first argument. The default implementation of `stdout` and
+ * `stderr` writes to the console using `console.log` and `console.error`.
+ *
+ * R code can be sent as input by calling the ``stdin`` method with a single
+ * line of textual input.
+ *
+ * A long running R computation can be interrupted by calling the `interrupt`
+ * method.
+ *
+ * The ``prompt`` callback function is called when webR produces a prompt at
+ * the REPL console and is therefore awaiting user input. The prompt character
+ * (usually ``>`` or ``+``) is given as the first argument to the callback
+ * function. The default implementation of `prompt` shows a JavaScript prompt
+ * asking the user for input, and then sends the user input to `stdin`.
+ *
+ * The ``canvasExec`` callback function is called when webR writes plots to
+ * the built-in HTML canvas graphics device.
+ *
+ * Once constructed, start the Console using the ``run`` method. The `run`
+ * method starts an asynchronous infinite loop that waits for output from the
+ * webR worker and then calls the relevant callbacks.
+ */
+export declare class Console {
+    #private;
+    /** The supporting instance of webR */
+    webR: WebR;
+    /**
+     * A HTML canvas element
+     *
+     * The canvas graphics device writes to this element by default. Undefined
+     * when HTML canvas is unsupported.
+     */
+    canvas: HTMLCanvasElement | undefined;
+    /**
+     * @param {ConsoleCallbacks} callbacks A list of webR Console callbacks to
+     * be used for this console.
+     * @param {WebROptions} options The options to use for the new instance of
+     * webR started to support this console.
+     */
+    constructor(callbacks?: ConsoleCallbacks, options?: WebROptions);
+    /**
+     * Write a line of input to webR's REPL through ``stdin``
+     * @param {string} input A line of input text.
+     */
+    stdin(input: string): void;
+    /**
+     * Interrupt a long running R computation and return to the prompt
+     */
+    interrupt(): void;
+    /**
+     * Start the webR console
+     */
+    run(): void;
+}

package/dist/webR/emscripten.d.ts

@@ -0,0 +1,126 @@
+/// <reference types="emscripten" />
+import type { RPtr, RTypeNumber } from './robj';
+import type { UnwindProtectException } from './utils-r';
+export interface Module extends EmscriptenModule {
+    FS: typeof FS & {
+        mkdirTree(path: string): void;
+    };
+    ENV: {
+        [key: string]: string;
+    };
+    GOT: {
+        [key: string]: {
+            required: boolean;
+            value: number;
+        };
+    };
+    createLazyFilesystem: () => void;
+    monitorRunDependencies: (n: number) => void;
+    noImageDecoding: boolean;
+    noAudioDecoding: boolean;
+    noWasmDecoding: boolean;
+    setPrompt: (prompt: string) => void;
+    canvasExec: (op: string) => void;
+    downloadFileContent: (URL: string, headers: Array<string>) => {
+        status: number;
+        response: string | ArrayBuffer;
+    };
+    allocateUTF8: typeof allocateUTF8;
+    allocateUTF8OnStack: typeof allocateUTF8OnStack;
+    getValue: typeof getValue;
+    setValue: typeof setValue;
+    UTF8ToString: typeof UTF8ToString;
+    callMain: (args: string[]) => void;
+    getWasmTableEntry: (entry: number) => Function;
+    _ATTRIB: (ptr: RPtr) => RPtr;
+    _CAR: (ptr: RPtr) => RPtr;
+    _CDR: (ptr: RPtr) => RPtr;
+    _CLOENV: (ptr: RPtr) => RPtr;
+    _COMPLEX: (ptr: RPtr) => RPtr;
+    _FRAME: (ptr: RPtr) => RPtr;
+    _INTEGER: (ptr: RPtr) => RPtr;
+    _INTERNAL: (ptr: RPtr) => RPtr;
+    _LENGTH: (ptr: RPtr) => number;
+    _LOGICAL: (ptr: RPtr) => RPtr;
+    _PRINTNAME: (ptr: RPtr) => RPtr;
+    _R_CHAR: (ptr: RPtr) => RPtr;
+    _RAW: (ptr: RPtr) => RPtr;
+    _REAL: (ptr: RPtr) => RPtr;
+    _SETCAR: (x: RPtr, y: RPtr) => void;
+    _STRING_ELT: (ptr: RPtr, idx: number) => RPtr;
+    _STRING_PTR: (ptr: RPtr) => RPtr;
+    _SYMVALUE: (ptr: RPtr) => RPtr;
+    _TAG: (ptr: RPtr) => RPtr;
+    _TYPEOF: (ptr: RPtr) => RPtr;
+    _VECTOR_ELT: (ptr: RPtr, idx: number) => RPtr;
+    _R_lsInternal3: (env: RPtr, all: number, sorted: number) => RPtr;
+    _R_MakeExternalPtr: (p: number, tag: RPtr, prot: RPtr) => RPtr;
+    _R_NewEnv: (enclos: RPtr, hash: number, size: number) => RPtr;
+    _R_ParseEvalString: (code: number, env: RPtr) => RPtr;
+    _R_PreserveObject: (ptr: RPtr) => void;
+    _R_ReleaseObject: (ptr: RPtr) => void;
+    _Rf_ScalarReal: (n: number) => RPtr;
+    _Rf_ScalarLogical: (l: number) => RPtr;
+    _Rf_ScalarInteger: (n: number) => RPtr;
+    _Rf_ScalarString: (s: string) => RPtr;
+    _Rf_allocList: (len: number) => RPtr;
+    _Rf_allocVector: (type: RTypeNumber, len: number) => RPtr;
+    _Rf_defineVar: (symbol: RPtr, value: RPtr, env: RPtr) => void;
+    _Rf_error: (msg: EmPtr) => void;
+    _Rf_eval: (call: RPtr, env: RPtr) => RPtr;
+    _Rf_findVarInFrame: (rho: RPtr, symbol: RPtr) => RPtr;
+    _Rf_listAppend: (source: RPtr, target: RPtr) => RPtr;
+    _Rf_getAttrib: (ptr1: RPtr, ptr2: RPtr) => RPtr;
+    _Rf_install: (ptr: number) => RPtr;
+    _Rf_installTrChar: (name: RPtr) => RPtr;
+    _Rf_lang1: (ptr1: RPtr) => RPtr;
+    _Rf_lang2: (ptr1: RPtr, ptr2: RPtr) => RPtr;
+    _Rf_lang3: (ptr1: RPtr, ptr2: RPtr, ptr3: RPtr) => RPtr;
+    _Rf_lang4: (ptr1: RPtr, ptr2: RPtr, ptr3: RPtr, ptr4: RPtr) => RPtr;
+    _Rf_lang5: (ptr1: RPtr, ptr2: RPtr, ptr3: RPtr, ptr4: RPtr, ptr5: RPtr) => RPtr;
+    _Rf_lang6: (ptr1: RPtr, ptr2: RPtr, ptr3: RPtr, ptr4: RPtr, ptr5: RPtr, ptr6: RPtr) => RPtr;
+    _Rf_mkChar: (ptr: number) => RPtr;
+    _Rf_mkString: (ptr: number) => RPtr;
+    _Rf_onintr: () => void;
+    _Rf_protect: (ptr: RPtr) => RPtr;
+    _R_ContinueUnwind: (cont: RPtr) => never;
+    _R_ProtectWithIndex: (ptr1: RPtr, ptr2: RPtr) => void;
+    _R_Reprotect: (ptr1: RPtr, ptr2: RPtr) => void;
+    _Rf_setAttrib: (ptr1: RPtr, ptr2: RPtr, ptr3: RPtr) => RPtr;
+    _Rf_unprotect: (n: number) => void;
+    _Rf_unprotect_ptr: (ptr: RPtr) => void;
+    _R_BaseEnv: RPtr;
+    _R_BracketSymbol: RPtr;
+    _R_Bracket2Symbol: RPtr;
+    _R_DollarSymbol: RPtr;
+    _R_EmptyEnv: RPtr;
+    _R_FalseValue: RPtr;
+    _R_GlobalEnv: RPtr;
+    _R_Interactive: RPtr;
+    _R_NaInt: RPtr;
+    _R_NaReal: RPtr;
+    _R_NaString: RPtr;
+    _R_LogicalNAValue: RPtr;
+    _R_NilValue: RPtr;
+    _R_TrueValue: RPtr;
+    _R_NamesSymbol: RPtr;
+    _R_UnboundValue: RPtr;
+    _SET_STRING_ELT: (ptr: RPtr, idx: number, val: RPtr) => void;
+    _SET_VECTOR_ELT: (ptr: RPtr, idx: number, val: RPtr) => void;
+    webr: {
+        UnwindProtectException: typeof UnwindProtectException;
+        readConsole: () => number;
+        resolveInit: () => void;
+        handleEvents: () => void;
+        evalJs: (code: RPtr) => number;
+        setTimeoutWasm: (ptr: EmPtr, data: EmPtr, delay: number) => void;
+    };
+}
+export declare const Module: Module;
+export type EmPtr = ReturnType<typeof Module.allocateUTF8>;
+export interface DictEmPtrs {
+    [key: string]: EmPtr;
+}
+export declare function dictEmFree(dict: {
+    [key: string | number]: EmPtr;
+}): void;

package/dist/webR/payload.d.ts

@@ -0,0 +1,47 @@
+/**
+ * Types containing references to R objects, raw data or errors over the webR
+ * communication channel.
+ * @module Payload
+ */
+import { WebRDataRaw, RPtr, RType } from './robj';
+export type WebRPayloadRaw = {
+    obj: WebRDataRaw;
+    payloadType: 'raw';
+};
+export type WebRPayloadPtr = {
+    obj: {
+        type?: RType;
+        ptr: RPtr;
+        methods?: string[];
+    };
+    payloadType: 'ptr';
+};
+export type WebRPayloadErr = {
+    obj: {
+        message: string;
+        name: string;
+        stack?: string;
+    };
+    payloadType: 'err';
+};
+export type WebRPayload = WebRPayloadRaw | WebRPayloadPtr;
+export type WebRPayloadWorker = WebRPayloadRaw | WebRPayloadPtr | WebRPayloadErr;
+export declare function webRPayloadError(payload: WebRPayloadErr): Error;
+/**
+ * Test for an WebRPayload instance.
+ * @param {any} value The object to test.
+ * @returns {boolean} True if the object is an instance of an WebRPayload.
+ */
+export declare function isWebRPayload(value: any): value is WebRPayload;
+/**
+ * Test for an WebRPayloadPtr instance.
+ * @param {any} value The object to test.
+ * @returns {boolean} True if the object is an instance of an WebRPayloadPtr.
+ */
+export declare function isWebRPayloadPtr(value: any): value is WebRPayloadPtr;
+/**
+ * Test for an WebRPayloadRaw instance.
+ * @param {any} value The object to test.
+ * @returns {boolean} True if the object is an instance of an WebRPayloadRaw.
+ */
+export declare function isWebRPayloadRaw(value: any): value is WebRPayloadRaw;

package/dist/webR/proxy.d.ts

@@ -0,0 +1,115 @@
+/**
+ * Proxy R objects on the webR worker thread so that they can be accessed from
+ * the main thread.
+ * @module Proxy
+ */
+import { ChannelMain } from './chan/channel';
+import { WebRPayloadPtr } from './payload';
+import { RType } from './robj';
+import * as RWorker from './robj-worker';
+import { ShelterID } from './webr-chan';
+/**
+ * Obtain a union of the keys corresponding to methods of a given class `T`.
+ * @typeParam T The type to provide the methods for.
+ */
+export type Methods<T> = {
+    [P in keyof T]: T[P] extends (...args: any) => any ? P : never;
+}[keyof T];
+/**
+ * Distributive conditional type for {@link RProxy}.
+ *
+ * Distributes {@link RProxy} over any {@link RWorker.RObject} in the given
+ * union type U.
+ * @typeParam U The type union to distribute {@link RProxy} over.
+ */
+export type DistProxy<U> = U extends RWorker.RObject ? RProxy<U> : U;
+/**
+ * Convert {@link RWorker.RObject} properties for use with an {@link RProxy}.
+ *
+ * Properties in the type parameter `T` are mapped so that {@link RProxy} is
+ * distributed over any {@link RWorker.RObject} types, then wrapped in a
+ * Promise.
+ *
+ * Function signatures are mapped so that arguments with {@link RWorker.RObject}
+ * type instead take {@link RProxy}<{@link RWorker.RObject}> type. Other
+ * function arguments remain as they are. The function return type is also
+ * converted to a corresponding type using `RProxify` recursively.
+ * @typeParam T The type to convert.
+ */
+export type RProxify<T> = T extends Array<any> ? Promise<DistProxy<T[0]>[]> : T extends (...args: infer U) => any ? (...args: {
+    [V in keyof U]: DistProxy<U[V]>;
+}) => RProxify<ReturnType<T>> : Promise<DistProxy<T>>;
+/**
+ * Create an {@link RProxy} based on an {@link RWorker.RObject} type parameter.
+ *
+ * R objects created via an {@link RProxy} are intended to be used in place of
+ * {@link RWorker.RObject} on the main thread. An {@link RProxy} object has the
+ * same instance methods as the given {@link RWorker.RObject} parameter, with
+ * the following differences:
+ * * Method arguments take `RProxy` in place of {@link RWorker.RObject}.
+ *
+ * * Where an {@link RWorker.RObject} would be returned, an `RProxy` is
+ *   returned instead.
+ *
+ * * All return types are wrapped in a Promise.
+ *
+ * If required, the {@link Payload.WebRPayloadPtr} object associated with the
+ * proxy can be accessed directly through the `_payload` property.
+ * @typeParam T The {@link RWorker.RObject} type to convert into `RProxy` type.
+ */
+export type RProxy<T extends RWorker.RObject> = {
+    [P in Methods<T>]: RProxify<T[P]>;
+} & {
+    _payload: WebRPayloadPtr;
+    [Symbol.asyncIterator](): AsyncGenerator<RProxy<RWorker.RObject>, void, unknown>;
+};
+/**
+ * Create a proxy constructor based on a {@link RWorker.RObject} class.
+ *
+ * The class constructors and static methods of the given subclass of
+ * {@link RWorker.RObject} are proxied, and the proxied constructor returns a
+ * promise to an R object of a given {@link RProxy} type.
+ * @typeParam T The type of the {@link RWorker.RObject} class to be proxied.
+ * @typeParam R The type to be returned from the proxied class constructor.
+ */
+export type ProxyConstructor<T, R> = (T extends abstract new (...args: infer U) => any ? {
+    new (...args: {
+        [V in keyof U]: U[V];
+    }): Promise<R>;
+} : never) & {
+    [P in Methods<typeof RWorker.RObject>]: RProxify<(typeof RWorker.RObject)[P]>;
+};
+/**
+ * Proxy an R object method by providing an async function that requests that
+ * the worker thread calls the method and then returns the result.
+ *
+ * When the optional payload argument has not been provided, an
+ * {@link RWorker.RObject} static method is called.
+ * @internal
+ */
+export declare function targetMethod(chan: ChannelMain, prop: string): any;
+export declare function targetMethod(chan: ChannelMain, prop: string, payload: WebRPayloadPtr): any;
+/**
+ * Proxy an R object.
+ *
+ * The proxy targets a particular R object in WebAssembly memory. Methods of the
+ * relevant subclass of {@link RWorker.RObject} are proxied, enabling
+ * structured manipulation of R objects from the main thread.
+ * @param {ChannelMain} chan The current main thread communication channel.
+ * @param {WebRPayloadPtr} payload A webR payload referencing an R object.
+ * @returns {RProxy<RWorker.RObject>} An {@link RObject} corresponding to the
+ * referenced R object.
+ */
+export declare function newRProxy(chan: ChannelMain, payload: WebRPayloadPtr): RProxy<RWorker.RObject>;
+/**
+ * Proxy an {@link RWorker.RObject} class.s
+ * @param {ChannelMain} chan The current main thread communication channel.
+ * @param {ShelterID} shelter The shelter ID to protect returned objects with.
+ * @param {(RType | 'object')} objType The R object type, or `'object'` for the
+ * generic {@link RWorker.RObject} class.
+ * @returns {ProxyConstructor} A proxy to the R object subclass corresponding to
+ * the given value of the `objType` argument.
+ * @typeParam T The type of the {@link RWorker.RObject} class to be proxied.
+ * @typeParam R The type to be returned from the proxied class constructor.
+ */
+export declare function newRClassProxy<T, R>(chan: ChannelMain, shelter: ShelterID, objType: RType | 'object'): ProxyConstructor<T, R>;

package/dist/webR/robj-main.d.ts

@@ -0,0 +1,112 @@
+/**
+ * Module for working with R objects on the main thead through
+ * JavaScript proxies. The `RObject` types in `RMain` are aliases for
+ * proxies to the corresponding types in `RWorker`. For instance,
+ * `RMain.RCharacter` is an alias for `RMain.RProxy<RWorker.RCharacter>`.
+ * The proxies automatically and asynchronously forward method and
+ * getter calls to the implementations on the R worker side.
+ * @module RMain
+ */
+import type { RProxy } from './proxy';
+import * as RWorker from './robj-worker';
+export type RObject = RProxy<RWorker.RObject>;
+export type RNull = RProxy<RWorker.RNull>;
+export type RSymbol = RProxy<RWorker.RSymbol>;
+export type RPairlist = RProxy<RWorker.RPairlist>;
+export type REnvironment = RProxy<RWorker.REnvironment>;
+export type RString = RProxy<RWorker.RString>;
+export type RLogical = RProxy<RWorker.RLogical>;
+export type RInteger = RProxy<RWorker.RInteger>;
+export type RDouble = RProxy<RWorker.RDouble>;
+export type RComplex = RProxy<RWorker.RComplex>;
+export type RCharacter = RProxy<RWorker.RCharacter>;
+export type RList = RProxy<RWorker.RList>;
+export type RRaw = RProxy<RWorker.RRaw>;
+export type RCall = RProxy<RWorker.RCall>;
+export type RFunction = RProxy<RWorker.RFunction> & ((...args: unknown[]) => Promise<unknown>);
+/**
+ * Test for an RObject instance
+ *
+ * RObject is the user facing interface to R objects.
+ * @param {any} value The object to test.
+ * @returns {boolean} True if the object is an instance of an RObject.
+ */
+export declare function isRObject(value: any): value is RObject;
+/**
+ * Test for an RNull instance
+ * @param {any} value The object to test.
+ * @returns {boolean} True if the object is an instance of an RNull.
+ */
+export declare function isRNull(value: any): value is RNull;
+/**
+ * Test for an RSymbol instance
+ * @param {any} value The object to test.
+ * @returns {boolean} True if the object is an instance of an RSymbol.
+ */
+export declare function isRSymbol(value: any): value is RSymbol;
+/**
+ * Test for an RPairlist instance
+ * @param {any} value The object to test.
+ * @returns {boolean} True if the object is an instance of an RPairlist.
+ */
+export declare function isRPairlist(value: any): value is RPairlist;
+/**
+ * Test for an REnvironment instance
+ * @param {any} value The object to test.
+ * @returns {boolean} True if the object is an instance of an REnvironment.
+ */
+export declare function isREnvironment(value: any): value is REnvironment;
+/**
+ * Test for an RLogical instance
+ * @param {any} value The object to test.
+ * @returns {boolean} True if the object is an instance of an RLogical.
+ */
+export declare function isRLogical(value: any): value is RLogical;
+/**
+ * Test for an RInteger instance
+ * @param {any} value The object to test.
+ * @returns {boolean} True if the object is an instance of an RInteger.
+ */
+export declare function isRInteger(value: any): value is RInteger;
+/**
+ * Test for an RDouble instance
+ * @param {any} value The object to test.
+ * @returns {boolean} True if the object is an instance of an RDouble.
+ */
+export declare function isRDouble(value: any): value is RDouble;
+/**
+ * Test for an RComplex instance
+ * @param {any} value The object to test.
+ * @returns {boolean} True if the object is an instance of an RComplex.
+ */
+export declare function isRComplex(value: any): value is RComplex;
+/**
+ * Test for an RCharacter instance
+ * @param {any} value The object to test.
+ * @returns {boolean} True if the object is an instance of an RCharacter.
+ */
+export declare function isRCharacter(value: any): value is RCharacter;
+/**
+ * Test for an RList instance
+ * @param {any} value The object to test.
+ * @returns {boolean} True if the object is an instance of an RList.
+ */
+export declare function isRList(value: any): value is RList;
+/**
+ * Test for an RRaw instance
+ * @param {any} value The object to test.
+ * @returns {boolean} True if the object is an instance of an RRaw.
+ */
+export declare function isRRaw(value: any): value is RRaw;
+/**
+ * Test for an RCall instance
+ * @param {any} value The object to test.
+ * @returns {boolean} True if the object is an instance of an RCall.
+ */
+export declare function isRCall(value: any): value is RCall;
+/**
+ * Test for an RFunction instance
+ * @param {any} value The object to test.
+ * @returns {boolean} True if the object is an instance of an RFunction.
+ */
+export declare function isRFunction(value: any): value is RFunction;