@r-universe/webr 2023.6.21 → 2023.9.18

package/dist/webr-worker.js

@@ -42,6 +42,14 @@ var __privateSet = (obj, member, value, setter) => {
   setter ? setter.call(obj, value) : member.set(obj, value);
   return value;
 };
+var __privateWrapper = (obj, member, setter, getter) => ({
+  set _(value) {
+    __privateSet(obj, member, value, setter);
+  },
+  get _() {
+    return __privateGet(obj, member, getter);
+  }
+});
 var __privateMethod = (obj, member, method) => {
   __accessCheck(obj, member, "access private method");
   return method;
@@ -1936,6 +1944,19 @@ var require_XMLHttpRequest = __commonJS({
   }
 });
 
+// webR/error.ts
+var WebRError = class extends Error {
+  constructor(msg) {
+    super(msg);
+    this.name = this.constructor.name;
+    Object.setPrototypeOf(this, new.target.prototype);
+  }
+};
+var WebRWorkerError = class extends WebRError {
+};
+var WebRChannelError = class extends WebRError {
+};
+
 // webR/compat.ts
 var IN_NODE = typeof process !== "undefined" && process.release && process.release.name === "node";
 var loadScript;
@@ -1965,7 +1986,7 @@ if (globalThis.document) {
     await Promise.resolve().then(() => __toESM(require(nodePathMod.resolve(url))));
   };
 } else {
-  throw new Error("Cannot determine runtime environment");
+  throw new WebRError("Cannot determine runtime environment");
 }
 
 // webR/utils.ts
@@ -2025,7 +2046,7 @@ function isCrossOrigin(urlString) {
 function throwUnreachable(context) {
   let msg = "Reached the unreachable";
   msg = msg + (context ? ": " + context : ".");
-  throw new Error(msg);
+  throw new WebRError(msg);
 }
 
 // webR/chan/task-common.ts
@@ -2208,9 +2229,11 @@ function newSyncRequest(msg, data) {
 }
 
 // webR/payload.ts
-function webRPayloadError(payload) {
-  const e = new Error(payload.obj.message);
-  e.name = payload.obj.name;
+function webRPayloadAsError(payload) {
+  const e = new WebRWorkerError(payload.obj.message);
+  if (payload.obj.name !== "Error") {
+    e.name = payload.obj.name;
+  }
   e.stack = payload.obj.stack;
   return e;
 }
@@ -2263,7 +2286,7 @@ var ChannelMain = class {
       const payload = msg.data.resp;
       __privateGet(this, _parked).delete(uuid);
       if (payload.payloadType === "err") {
-        handles.reject(webRPayloadError(payload));
+        handles.reject(webRPayloadAsError(payload));
       } else {
         handles.resolve(payload);
       }
@@ -2454,9 +2477,9 @@ function setInterruptBuffer(buffer) {
 }
 
 // webR/emscripten.ts
-var Module = {};
+var Module2 = {};
 function dictEmFree(dict) {
-  Object.keys(dict).forEach((key) => Module._free(dict[key]));
+  Object.keys(dict).forEach((key) => Module2._free(dict[key]));
 }
 
 // webR/chan/channel-shared.ts
@@ -2500,12 +2523,12 @@ var SharedBufferChannelMain = class extends ChannelMain {
               break;
             }
             default:
-              throw new TypeError(`Unsupported request type '${payload.type}'.`);
+              throw new WebRChannelError(`Unsupported request type '${payload.type}'.`);
           }
           return;
         }
         case "request":
-          throw new TypeError(
+          throw new WebRChannelError(
             "Can't send messages of type 'request' from a worker. Please Use 'sync-request' instead."
           );
       }
@@ -2535,7 +2558,7 @@ var SharedBufferChannelMain = class extends ChannelMain {
   }
   interrupt() {
     if (!__privateGet(this, _interruptBuffer)) {
-      throw new Error("Failed attempt to interrupt before initialising interruptBuffer");
+      throw new WebRChannelError("Failed attempt to interrupt before initialising interruptBuffer");
     }
     this.inputQueue.reset();
     __privateGet(this, _interruptBuffer)[0] = 1;
@@ -2561,6 +2584,8 @@ var SharedBufferChannelWorker = class {
     __privateAdd(this, _interruptBuffer2, new Int32Array(new SharedArrayBuffer(4)));
     __privateAdd(this, _interrupt, () => {
     });
+    this.onMessageFromMainThread = () => {
+    };
     __privateSet(this, _ep, IN_NODE ? require("worker_threads").parentPort : globalThis);
     setInterruptBuffer(__privateGet(this, _interruptBuffer2).buffer);
     setInterruptHandler(() => this.handleInterrupt());
@@ -2583,13 +2608,13 @@ var SharedBufferChannelWorker = class {
     for (; ; ) {
       const msg = this.read();
       if (msg.type === "stdin") {
-        return Module.allocateUTF8(msg.data);
+        return Module2.allocateUTF8(msg.data);
       }
       __privateGet(this, _dispatch).call(this, msg);
     }
   }
   run(args) {
-    Module.callMain(args);
+    Module2.callMain(args);
   }
   setInterrupt(interrupt) {
     __privateSet(this, _interrupt, interrupt);
@@ -2649,7 +2674,7 @@ var ServiceWorkerChannelMain = class extends ChannelMain {
           return;
         }
         case "request":
-          throw new TypeError(
+          throw new WebRChannelError(
             "Can't send messages of type 'request' from a worker.Use service worker fetch request instead."
           );
       }
@@ -2689,7 +2714,7 @@ var ServiceWorkerChannelMain = class extends ChannelMain {
   activeRegistration() {
     var _a;
     if (!((_a = __privateGet(this, _registration)) == null ? void 0 : _a.active)) {
-      throw new Error("Attempted to obtain a non-existent active registration.");
+      throw new WebRChannelError("Attempted to obtain a non-existent active registration.");
     }
     return __privateGet(this, _registration).active;
   }
@@ -2731,7 +2756,7 @@ onMessageFromServiceWorker_fn = async function(event) {
     const uuid = event.data.data;
     const message = __privateGet(this, _syncMessageCache).get(uuid);
     if (!message) {
-      throw new Error("Request not found during service worker XHR request");
+      throw new WebRChannelError("Request not found during service worker XHR request");
     }
     __privateGet(this, _syncMessageCache).delete(uuid);
     switch (message.type) {
@@ -2756,7 +2781,7 @@ onMessageFromServiceWorker_fn = async function(event) {
         break;
       }
       default:
-        throw new TypeError(`Unsupported request type '${message.type}'.`);
+        throw new WebRChannelError(`Unsupported request type '${message.type}'.`);
     }
     return;
   }
@@ -2772,19 +2797,20 @@ handleEventsFromWorker_fn2 = function(worker) {
   }
 };
 _onMessageFromWorker2 = new WeakMap();
-var _ep2, _mainThreadId, _location, _dispatch2, _interrupt2;
+var _ep2, _mainThreadId, _location, _lastInterruptReq, _dispatch2, _interrupt2;
 var ServiceWorkerChannelWorker = class {
   constructor(data) {
     __privateAdd(this, _ep2, void 0);
     __privateAdd(this, _mainThreadId, void 0);
     __privateAdd(this, _location, void 0);
+    __privateAdd(this, _lastInterruptReq, Date.now());
     __privateAdd(this, _dispatch2, () => 0);
     __privateAdd(this, _interrupt2, () => {
     });
     this.onMessageFromMainThread = () => {
     };
     if (!data.clientId || !data.location) {
-      throw Error("Can't start service worker channel");
+      throw new WebRChannelError("Can't start service worker channel");
     }
     __privateSet(this, _mainThreadId, data.clientId);
     __privateSet(this, _location, data.location);
@@ -2833,22 +2859,25 @@ var ServiceWorkerChannelWorker = class {
     for (; ; ) {
       const msg = this.read();
       if (msg.type === "stdin") {
-        return Module.allocateUTF8(msg.data);
+        return Module2.allocateUTF8(msg.data);
       }
       __privateGet(this, _dispatch2).call(this, msg);
     }
   }
   run(args) {
-    Module.callMain(args);
+    Module2.callMain(args);
   }
   setInterrupt(interrupt) {
     __privateSet(this, _interrupt2, interrupt);
   }
   handleInterrupt() {
-    const response = this.syncRequest({ type: "interrupt" });
-    const interrupted = response.data.resp;
-    if (interrupted) {
-      __privateGet(this, _interrupt2).call(this);
+    if (Date.now() > __privateGet(this, _lastInterruptReq) + 1e3) {
+      __privateSet(this, _lastInterruptReq, Date.now());
+      const response = this.syncRequest({ type: "interrupt" });
+      const interrupted = response.data.resp;
+      if (interrupted) {
+        __privateGet(this, _interrupt2).call(this);
+      }
     }
   }
   setDispatchHandler(dispatch2) {
@@ -2858,14 +2887,239 @@ var ServiceWorkerChannelWorker = class {
 _ep2 = new WeakMap();
 _mainThreadId = new WeakMap();
 _location = new WeakMap();
+_lastInterruptReq = new WeakMap();
 _dispatch2 = new WeakMap();
 _interrupt2 = new WeakMap();
 
+// webR/chan/channel-postmessage.ts
+if (IN_NODE) {
+  globalThis.Worker = require("worker_threads").Worker;
+}
+var _worker, _handleEventsFromWorker3, handleEventsFromWorker_fn3, _onMessageFromWorker3;
+var PostMessageChannelMain = class extends ChannelMain {
+  constructor(config) {
+    super();
+    __privateAdd(this, _handleEventsFromWorker3);
+    this.close = () => {
+    };
+    __privateAdd(this, _worker, void 0);
+    __privateAdd(this, _onMessageFromWorker3, async (worker, message) => {
+      if (!message || !message.type) {
+        return;
+      }
+      switch (message.type) {
+        case "resolve":
+          this.resolve();
+          return;
+        case "response":
+          this.resolveResponse(message);
+          return;
+        case "system":
+          this.systemQueue.put(message.data);
+          return;
+        default:
+          this.outputQueue.put(message);
+          return;
+        case "request": {
+          const msg = message;
+          const payload = msg.data.msg;
+          switch (payload.type) {
+            case "read": {
+              const input = await this.inputQueue.get();
+              if (__privateGet(this, _worker)) {
+                const response = newResponse(msg.data.uuid, input);
+                __privateGet(this, _worker).postMessage(response);
+              }
+              break;
+            }
+            default:
+              throw new WebRChannelError(`Unsupported request type '${payload.type}'.`);
+          }
+          return;
+        }
+        case "sync-request":
+          throw new WebRChannelError(
+            "Can't send messages of type 'sync-request' in PostMessage mode. Use 'request' instead."
+          );
+      }
+    });
+    const initWorker = (worker) => {
+      __privateSet(this, _worker, worker);
+      __privateMethod(this, _handleEventsFromWorker3, handleEventsFromWorker_fn3).call(this, worker);
+      this.close = () => worker.terminate();
+      const msg = {
+        type: "init",
+        data: { config, channelType: ChannelType.PostMessage }
+      };
+      worker.postMessage(msg);
+    };
+    if (isCrossOrigin(config.baseUrl)) {
+      newCrossOriginWorker(
+        `${config.baseUrl}webr-worker.js`,
+        (worker) => initWorker(worker)
+      );
+    } else {
+      const worker = new Worker(`${config.baseUrl}webr-worker.js`);
+      initWorker(worker);
+    }
+    ({ resolve: this.resolve, promise: this.initialised } = promiseHandles());
+  }
+  interrupt() {
+    console.error("Interrupting R execution is not available when using the PostMessage channel");
+  }
+};
+_worker = new WeakMap();
+_handleEventsFromWorker3 = new WeakSet();
+handleEventsFromWorker_fn3 = function(worker) {
+  if (IN_NODE) {
+    worker.on("message", (message) => {
+      __privateGet(this, _onMessageFromWorker3).call(this, worker, message);
+    });
+  } else {
+    worker.onmessage = (ev) => __privateGet(this, _onMessageFromWorker3).call(this, worker, ev.data);
+  }
+};
+_onMessageFromWorker3 = new WeakMap();
+var _ep3, _parked2, _dispatch3, _promptDepth, _interrupt3, _asyncREPL;
+var PostMessageChannelWorker = class {
+  constructor() {
+    __privateAdd(this, _ep3, void 0);
+    __privateAdd(this, _parked2, /* @__PURE__ */ new Map());
+    __privateAdd(this, _dispatch3, () => 0);
+    __privateAdd(this, _promptDepth, 0);
+    __privateAdd(this, _interrupt3, () => {
+    });
+    /*
+     * This is a fallback REPL for webR running in PostMessage mode. The prompt
+     * section of R's R_ReplDLLdo1 returns empty with -1, which allows this
+     * fallback REPL to yield to the event loop with await.
+     *
+     * The drawback of this approach is that nested REPLs do not work, such as
+     * realine, browser or menu. Attempting to use a nested REPL prints an error
+     * to the JS console.
+     *
+     * R/Wasm errors during execution are caught and the REPL is restarted at the
+     * top level. Any other JS errors are re-thrown.
+     */
+    __privateAdd(this, _asyncREPL, async () => {
+      for (; ; ) {
+        try {
+          __privateSet(this, _promptDepth, 0);
+          const msg = await this.request({ type: "read" });
+          if (msg.type === "stdin") {
+            const str = Module.allocateUTF8(msg.data);
+            Module._strcpy(Module._DLLbuf, str);
+            Module.setValue(Module._DLLbufp, Module._DLLbuf, "*");
+            Module._free(str);
+            try {
+              while (Module._R_ReplDLLdo1() > 0)
+                ;
+            } catch (e) {
+              if (e instanceof WebAssembly.Exception) {
+                Module._R_ReplDLLinit();
+                Module._R_ReplDLLdo1();
+              } else {
+                throw e;
+              }
+            }
+          } else {
+            __privateGet(this, _dispatch3).call(this, msg);
+          }
+        } catch (e) {
+          if (!(e instanceof WebAssembly.Exception)) {
+            throw e;
+          }
+        }
+      }
+    });
+    __privateSet(this, _ep3, IN_NODE ? require("worker_threads").parentPort : globalThis);
+  }
+  resolve() {
+    this.write({ type: "resolve" });
+  }
+  write(msg, transfer2) {
+    __privateGet(this, _ep3).postMessage(msg, transfer2);
+  }
+  writeSystem(msg, transfer2) {
+    __privateGet(this, _ep3).postMessage({ type: "system", data: msg }, transfer2);
+  }
+  read() {
+    throw new WebRChannelError(
+      "Unable to synchronously read when using the `PostMessage` channel."
+    );
+  }
+  inputOrDispatch() {
+    if (__privateGet(this, _promptDepth) > 10) {
+      __privateGet(this, _interrupt3).call(this);
+    } else if (__privateGet(this, _promptDepth) > 0) {
+      this.writeSystem({
+        type: "console.error",
+        data: "Nested REPL prompts are not available when using the `PostMessage` channel."
+      });
+    }
+    __privateWrapper(this, _promptDepth)._++;
+    return 0;
+  }
+  run(_args) {
+    const args = _args || [];
+    args.unshift("R");
+    const argc = args.length;
+    const argv = Module._malloc(4 * (argc + 1));
+    args.forEach((arg, idx) => {
+      const argvPtr = argv + 4 * idx;
+      const argPtr = Module.allocateUTF8(arg);
+      Module.setValue(argvPtr, argPtr, "*");
+    });
+    this.writeSystem({
+      type: "console.warn",
+      data: "WebR is using `PostMessage` communication channel, nested R REPLs are not available."
+    });
+    Module._Rf_initialize_R(argc, argv);
+    Module._setup_Rmainloop();
+    Module._R_ReplDLLinit();
+    Module._R_ReplDLLdo1();
+    __privateGet(this, _asyncREPL).call(this);
+  }
+  setDispatchHandler(dispatch2) {
+    __privateSet(this, _dispatch3, dispatch2);
+  }
+  async request(msg, transferables) {
+    const req = newRequest(msg, transferables);
+    const { resolve, promise: prom } = promiseHandles();
+    __privateGet(this, _parked2).set(req.data.uuid, resolve);
+    this.write(req);
+    return prom;
+  }
+  setInterrupt(interrupt) {
+    __privateSet(this, _interrupt3, interrupt);
+  }
+  handleInterrupt() {
+  }
+  onMessageFromMainThread(message) {
+    const msg = message;
+    const uuid = msg.data.uuid;
+    const resolve = __privateGet(this, _parked2).get(uuid);
+    if (resolve) {
+      __privateGet(this, _parked2).delete(uuid);
+      resolve(msg.data.resp);
+    } else {
+      console.warn("Can't find request.");
+    }
+  }
+};
+_ep3 = new WeakMap();
+_parked2 = new WeakMap();
+_dispatch3 = new WeakMap();
+_promptDepth = new WeakMap();
+_interrupt3 = new WeakMap();
+_asyncREPL = new WeakMap();
+
 // webR/chan/channel-common.ts
 var ChannelType = {
   Automatic: 0,
   SharedArrayBuffer: 1,
-  ServiceWorker: 2
+  ServiceWorker: 2,
+  PostMessage: 3
 };
 function newChannelWorker(msg) {
   switch (msg.data.channelType) {
@@ -2873,8 +3127,10 @@ function newChannelWorker(msg) {
       return new SharedBufferChannelWorker();
     case ChannelType.ServiceWorker:
       return new ServiceWorkerChannelWorker(msg.data);
+    case ChannelType.PostMessage:
+      return new PostMessageChannelWorker();
     default:
-      throw new Error("Unknown worker channel type recieved");
+      throw new WebRChannelError("Unknown worker channel type recieved");
   }
 }
 
@@ -2917,33 +3173,33 @@ function isComplex(value) {
 
 // webR/utils-r.ts
 function protect(x) {
-  Module._Rf_protect(handlePtr(x));
+  Module2._Rf_protect(handlePtr(x));
   return x;
 }
 function protectInc(x, prot) {
-  Module._Rf_protect(handlePtr(x));
+  Module2._Rf_protect(handlePtr(x));
   ++prot.n;
   return x;
 }
 function protectWithIndex(x) {
-  const pLoc = Module._malloc(4);
-  Module._R_ProtectWithIndex(handlePtr(x), pLoc);
-  const loc = Module.getValue(pLoc, "i32");
+  const pLoc = Module2._malloc(4);
+  Module2._R_ProtectWithIndex(handlePtr(x), pLoc);
+  const loc = Module2.getValue(pLoc, "i32");
   return { loc, ptr: pLoc };
 }
 function unprotectIndex(index) {
-  Module._Rf_unprotect(1);
-  Module._free(index.ptr);
+  Module2._Rf_unprotect(1);
+  Module2._free(index.ptr);
 }
 function reprotect(x, index) {
-  Module._R_Reprotect(handlePtr(x), index.loc);
+  Module2._R_Reprotect(handlePtr(x), index.loc);
   return x;
 }
 function unprotect(n) {
-  Module._Rf_unprotect(n);
+  Module2._Rf_unprotect(n);
 }
 function envPoke(env, sym, value) {
-  Module._Rf_defineVar(handlePtr(sym), handlePtr(value), handlePtr(env));
+  Module2._Rf_defineVar(handlePtr(sym), handlePtr(value), handlePtr(env));
 }
 function parseEvalBare(code, env) {
   const strings = {};
@@ -2951,8 +3207,8 @@ function parseEvalBare(code, env) {
   try {
     const envObj = new REnvironment(env);
     protectInc(envObj, prot);
-    strings.code = Module.allocateUTF8(code);
-    const out = Module._R_ParseEvalString(strings.code, envObj.ptr);
+    strings.code = Module2.allocateUTF8(code);
+    const out = Module2._R_ParseEvalString(strings.code, envObj.ptr);
     return RObject.wrap(out);
   } finally {
     dictEmFree(strings);
@@ -2967,7 +3223,7 @@ var UnwindProtectException = class extends Error {
   }
 };
 function safeEval(call, env) {
-  return Module.getWasmTableEntry(Module.GOT.ffi_safe_eval.value)(
+  return Module2.getWasmTableEntry(Module2.GOT.ffi_safe_eval.value)(
     handlePtr(call),
     handlePtr(env)
   );
@@ -2982,14 +3238,14 @@ function handlePtr(x) {
   }
 }
 function assertRType(obj, type) {
-  if (Module._TYPEOF(obj.ptr) !== RTypeMap[type]) {
+  if (Module2._TYPEOF(obj.ptr) !== RTypeMap[type]) {
     throw new Error(`Unexpected object type "${obj.type()}" when expecting type "${type}"`);
   }
 }
 var shelters = /* @__PURE__ */ new Map();
 function keep(shelter, x) {
   const ptr = handlePtr(x);
-  Module._R_PreserveObject(ptr);
+  Module2._R_PreserveObject(ptr);
   if (shelter === void 0) {
     return;
   }
@@ -3001,7 +3257,7 @@ function keep(shelter, x) {
 }
 function destroy(shelter, x) {
   const ptr = handlePtr(x);
-  Module._R_ReleaseObject(ptr);
+  Module2._R_ReleaseObject(ptr);
   const objs2 = shelters.get(shelter);
   const loc = objs2.indexOf(ptr);
   if (loc < 0) {
@@ -3013,7 +3269,7 @@ function purge(shelter) {
   const ptrs = shelters.get(shelter);
   for (const ptr of ptrs) {
     try {
-      Module._R_ReleaseObject(ptr);
+      Module2._R_ReleaseObject(ptr);
     } catch (e) {
       console.error(e);
     }
@@ -3062,7 +3318,7 @@ var RObjectBase = class {
     this.ptr = ptr;
   }
   type() {
-    const typeNumber = Module._TYPEOF(this.ptr);
+    const typeNumber = Module2._TYPEOF(this.ptr);
     const type = Object.keys(RTypeMap).find(
       (typeName) => RTypeMap[typeName] === typeNumber
     );
@@ -3079,7 +3335,7 @@ var _RObject = class extends RObjectBase {
     __privateAdd(this, _slice);
   }
   static wrap(ptr) {
-    const type = Module._TYPEOF(ptr);
+    const type = Module2._TYPEOF(ptr);
     return new (getRWorkerClass(type))(new RObjectBase(ptr));
   }
   get [Symbol.toStringTag]() {
@@ -3097,13 +3353,13 @@ var _RObject = class extends RObjectBase {
     parseEvalBare(".Internal(inspect(x))", { x: this });
   }
   isNull() {
-    return Module._TYPEOF(this.ptr) === RTypeMap.null;
+    return Module2._TYPEOF(this.ptr) === RTypeMap.null;
   }
   isUnbound() {
     return this.ptr === objs.unboundValue.ptr;
   }
   attrs() {
-    return RPairlist.wrap(Module._ATTRIB(this.ptr));
+    return RPairlist.wrap(Module2._ATTRIB(this.ptr));
   }
   setNames(values) {
     let namesObj;
@@ -3114,11 +3370,11 @@ var _RObject = class extends RObjectBase {
     } else {
       throw new Error("Argument to setNames must be null or an Array of strings or null");
     }
-    Module._Rf_setAttrib(this.ptr, objs.namesSymbol.ptr, namesObj.ptr);
+    Module2._Rf_setAttrib(this.ptr, objs.namesSymbol.ptr, namesObj.ptr);
     return this;
   }
   names() {
-    const names = RCharacter.wrap(Module._Rf_getAttrib(this.ptr, objs.namesSymbol.ptr));
+    const names = RCharacter.wrap(Module2._Rf_getAttrib(this.ptr, objs.namesSymbol.ptr));
     if (names.isNull()) {
       return null;
     } else {
@@ -3162,7 +3418,7 @@ var _RObject = class extends RObjectBase {
       const valueObj = new _RObject(value);
       protectInc(valueObj, prot);
       const assign = new RSymbol("[[<-");
-      const call = Module._Rf_lang4(assign.ptr, this.ptr, idx.ptr, valueObj.ptr);
+      const call = Module2._Rf_lang4(assign.ptr, this.ptr, idx.ptr, valueObj.ptr);
       protectInc(call, prot);
       return _RObject.wrap(safeEval(call, objs.baseEnv));
     } finally {
@@ -3186,7 +3442,7 @@ slice_fn = function(prop, op) {
   try {
     const idx = new _RObject(prop);
     protectInc(idx, prot);
-    const call = Module._Rf_lang3(op, this.ptr, idx.ptr);
+    const call = Module2._Rf_lang3(op, this.ptr, idx.ptr);
     protectInc(call, prot);
     return _RObject.wrap(safeEval(call, objs.baseEnv));
   } finally {
@@ -3195,7 +3451,7 @@ slice_fn = function(prop, op) {
 };
 var RNull = class extends RObject {
   constructor() {
-    super(new RObjectBase(Module.getValue(Module._R_NilValue, "*")));
+    super(new RObjectBase(Module2.getValue(Module2._R_NilValue, "*")));
     return this;
   }
   toJs() {
@@ -3212,11 +3468,11 @@ var RSymbol = class extends RObject {
       super(x);
       return;
     }
-    const name = Module.allocateUTF8(x);
+    const name = Module2.allocateUTF8(x);
     try {
-      super(new RObjectBase(Module._Rf_install(name)));
+      super(new RObjectBase(Module2._Rf_install(name)));
     } finally {
-      Module._free(name);
+      Module2._free(name);
     }
   }
   toJs() {
@@ -3239,13 +3495,13 @@ var RSymbol = class extends RObject {
     return this.printname().toString();
   }
   printname() {
-    return RString.wrap(Module._PRINTNAME(this.ptr));
+    return RString.wrap(Module2._PRINTNAME(this.ptr));
   }
   symvalue() {
-    return RObject.wrap(Module._SYMVALUE(this.ptr));
+    return RObject.wrap(Module2._SYMVALUE(this.ptr));
   }
   internal() {
-    return RObject.wrap(Module._INTERNAL(this.ptr));
+    return RObject.wrap(Module2._INTERNAL(this.ptr));
   }
 };
 var RPairlist = class extends RObject {
@@ -3258,7 +3514,7 @@ var RPairlist = class extends RObject {
     const prot = { n: 0 };
     try {
       const { names, values } = toWebRData(val);
-      const list = RPairlist.wrap(Module._Rf_allocList(values.length));
+      const list = RPairlist.wrap(Module2._Rf_allocList(values.length));
       protectInc(list, prot);
       for (let [i, next] = [0, list]; !next.isNull(); [i, next] = [i + 1, next.cdr()]) {
         next.setcar(new RObject(values[i]));
@@ -3321,16 +3577,16 @@ var RPairlist = class extends RObject {
     return name in this.toObject();
   }
   setcar(obj) {
-    Module._SETCAR(this.ptr, obj.ptr);
+    Module2._SETCAR(this.ptr, obj.ptr);
   }
   car() {
-    return RObject.wrap(Module._CAR(this.ptr));
+    return RObject.wrap(Module2._CAR(this.ptr));
   }
   cdr() {
-    return RObject.wrap(Module._CDR(this.ptr));
+    return RObject.wrap(Module2._CDR(this.ptr));
   }
   tag() {
-    return RObject.wrap(Module._TAG(this.ptr));
+    return RObject.wrap(Module2._TAG(this.ptr));
   }
 };
 var RCall = class extends RObject {
@@ -3344,7 +3600,7 @@ var RCall = class extends RObject {
     try {
       const { values } = toWebRData(val);
       const objs2 = values.map((value) => protectInc(new RObject(value), prot));
-      const call = RCall.wrap(Module._Rf_allocVector(RTypeMap.call, values.length));
+      const call = RCall.wrap(Module2._Rf_allocVector(RTypeMap.call, values.length));
       protectInc(call, prot);
       for (let [i, next] = [0, call]; !next.isNull(); [i, next] = [i + 1, next.cdr()]) {
         next.setcar(objs2[i]);
@@ -3355,13 +3611,13 @@ var RCall = class extends RObject {
     }
   }
   setcar(obj) {
-    Module._SETCAR(this.ptr, obj.ptr);
+    Module2._SETCAR(this.ptr, obj.ptr);
   }
   car() {
-    return RObject.wrap(Module._CAR(this.ptr));
+    return RObject.wrap(Module2._CAR(this.ptr));
   }
   cdr() {
-    return RObject.wrap(Module._CDR(this.ptr));
+    return RObject.wrap(Module2._CDR(this.ptr));
   }
   eval() {
     return RObject.wrap(safeEval(this.ptr, objs.baseEnv));
@@ -3377,10 +3633,10 @@ var RList = class extends RObject {
     const prot = { n: 0 };
     try {
       const { names, values } = toWebRData(val);
-      const ptr = Module._Rf_allocVector(RTypeMap.list, values.length);
+      const ptr = Module2._Rf_allocVector(RTypeMap.list, values.length);
       protectInc(ptr, prot);
       values.forEach((v, i) => {
-        Module._SET_VECTOR_ELT(ptr, i, new RObject(v).ptr);
+        Module2._SET_VECTOR_ELT(ptr, i, new RObject(v).ptr);
       });
       RObject.wrap(ptr).setNames(names);
       super(new RObjectBase(ptr));
@@ -3389,7 +3645,7 @@ var RList = class extends RObject {
     }
   }
   get length() {
-    return Module._LENGTH(this.ptr);
+    return Module2._LENGTH(this.ptr);
   }
   toArray(options = { depth: 1 }) {
     return this.toJs(options).values;
@@ -3449,15 +3705,15 @@ var RString = class extends RObject {
       super(x);
       return;
     }
-    const name = Module.allocateUTF8(x);
+    const name = Module2.allocateUTF8(x);
     try {
-      super(new RObjectBase(Module._Rf_mkChar(name)));
+      super(new RObjectBase(Module2._Rf_mkChar(name)));
     } finally {
-      Module._free(name);
+      Module2._free(name);
     }
   }
   toString() {
-    return Module.UTF8ToString(Module._R_CHAR(this.ptr));
+    return Module2.UTF8ToString(Module2._R_CHAR(this.ptr));
   }
   toJs() {
     return {
@@ -3476,7 +3732,7 @@ var REnvironment = class extends RObject {
     let nProt = 0;
     try {
       const { names, values } = toWebRData(val);
-      const ptr = protect(Module._R_NewEnv(objs.globalEnv.ptr, 0, 0));
+      const ptr = protect(Module2._R_NewEnv(objs.globalEnv.ptr, 0, 0));
       ++nProt;
       values.forEach((v, i) => {
         const name = names ? names[i] : null;
@@ -3497,7 +3753,7 @@ var REnvironment = class extends RObject {
     }
   }
   ls(all = false, sorted = true) {
-    const ls = RCharacter.wrap(Module._R_lsInternal3(this.ptr, Number(all), Number(sorted)));
+    const ls = RCharacter.wrap(Module2._R_lsInternal3(this.ptr, Number(all), Number(sorted)));
     return ls.toArray();
   }
   bind(name, value) {
@@ -3513,7 +3769,7 @@ var REnvironment = class extends RObject {
     return this.ls(true, true);
   }
   frame() {
-    return RObject.wrap(Module._FRAME(this.ptr));
+    return RObject.wrap(Module2._FRAME(this.ptr));
   }
   subset(prop) {
     if (typeof prop === "number") {
@@ -3555,7 +3811,7 @@ var RVectorAtomic = class extends RObject {
     const prot = { n: 0 };
     try {
       const { names, values } = toWebRData(val);
-      const ptr = Module._Rf_allocVector(RTypeMap[kind], values.length);
+      const ptr = Module2._Rf_allocVector(RTypeMap[kind], values.length);
       protectInc(ptr, prot);
       values.forEach(newSetter(ptr));
       RObject.wrap(ptr).setNames(names);
@@ -3565,7 +3821,7 @@ var RVectorAtomic = class extends RObject {
     }
   }
   get length() {
-    return Module._LENGTH(this.ptr);
+    return Module2._LENGTH(this.ptr);
   }
   get(prop) {
     return super.get(prop);
@@ -3579,7 +3835,7 @@ var RVectorAtomic = class extends RObject {
   detectMissing() {
     const prot = { n: 0 };
     try {
-      const call = Module._Rf_lang2(new RSymbol("is.na").ptr, this.ptr);
+      const call = Module2._Rf_lang2(new RSymbol("is.na").ptr, this.ptr);
       protectInc(call, prot);
       const val = RLogical.wrap(safeEval(call, objs.baseEnv));
       protectInc(val, prot);
@@ -3643,9 +3899,9 @@ var _RLogical = class extends RVectorAtomic {
   }
   toTypedArray() {
     return new Int32Array(
-      Module.HEAP32.subarray(
-        Module._LOGICAL(this.ptr) / 4,
-        Module._LOGICAL(this.ptr) / 4 + this.length
+      Module2.HEAP32.subarray(
+        Module2._LOGICAL(this.ptr) / 4,
+        Module2._LOGICAL(this.ptr) / 4 + this.length
       )
     );
   }
@@ -3657,10 +3913,10 @@ var _RLogical = class extends RVectorAtomic {
 var RLogical = _RLogical;
 _newSetter = new WeakMap();
 __privateAdd(RLogical, _newSetter, (ptr) => {
-  const data = Module._LOGICAL(ptr);
-  const naLogical = Module.getValue(Module._R_NaInt, "i32");
+  const data = Module2._LOGICAL(ptr);
+  const naLogical = Module2.getValue(Module2._R_NaInt, "i32");
   return (v, i) => {
-    Module.setValue(data + 4 * i, v === null ? naLogical : Boolean(v), "i32");
+    Module2.setValue(data + 4 * i, v === null ? naLogical : Boolean(v), "i32");
   };
 });
 var _newSetter2;
@@ -3683,9 +3939,9 @@ var _RInteger = class extends RVectorAtomic {
   }
   toTypedArray() {
     return new Int32Array(
-      Module.HEAP32.subarray(
-        Module._INTEGER(this.ptr) / 4,
-        Module._INTEGER(this.ptr) / 4 + this.length
+      Module2.HEAP32.subarray(
+        Module2._INTEGER(this.ptr) / 4,
+        Module2._INTEGER(this.ptr) / 4 + this.length
       )
     );
   }
@@ -3693,10 +3949,10 @@ var _RInteger = class extends RVectorAtomic {
 var RInteger = _RInteger;
 _newSetter2 = new WeakMap();
 __privateAdd(RInteger, _newSetter2, (ptr) => {
-  const data = Module._INTEGER(ptr);
-  const naInteger = Module.getValue(Module._R_NaInt, "i32");
+  const data = Module2._INTEGER(ptr);
+  const naInteger = Module2.getValue(Module2._R_NaInt, "i32");
   return (v, i) => {
-    Module.setValue(data + 4 * i, v === null ? naInteger : Math.round(Number(v)), "i32");
+    Module2.setValue(data + 4 * i, v === null ? naInteger : Math.round(Number(v)), "i32");
   };
 });
 var _newSetter3;
@@ -3719,17 +3975,17 @@ var _RDouble = class extends RVectorAtomic {
   }
   toTypedArray() {
     return new Float64Array(
-      Module.HEAPF64.subarray(Module._REAL(this.ptr) / 8, Module._REAL(this.ptr) / 8 + this.length)
+      Module2.HEAPF64.subarray(Module2._REAL(this.ptr) / 8, Module2._REAL(this.ptr) / 8 + this.length)
     );
   }
 };
 var RDouble = _RDouble;
 _newSetter3 = new WeakMap();
 __privateAdd(RDouble, _newSetter3, (ptr) => {
-  const data = Module._REAL(ptr);
-  const naDouble = Module.getValue(Module._R_NaReal, "double");
+  const data = Module2._REAL(ptr);
+  const naDouble = Module2.getValue(Module2._R_NaReal, "double");
   return (v, i) => {
-    Module.setValue(data + 8 * i, v === null ? naDouble : v, "double");
+    Module2.setValue(data + 8 * i, v === null ? naDouble : v, "double");
   };
 });
 var _newSetter4;
@@ -3752,9 +4008,9 @@ var _RComplex = class extends RVectorAtomic {
   }
   toTypedArray() {
     return new Float64Array(
-      Module.HEAPF64.subarray(
-        Module._COMPLEX(this.ptr) / 8,
-        Module._COMPLEX(this.ptr) / 8 + 2 * this.length
+      Module2.HEAPF64.subarray(
+        Module2._COMPLEX(this.ptr) / 8,
+        Module2._COMPLEX(this.ptr) / 8 + 2 * this.length
       )
     );
   }
@@ -3768,11 +4024,11 @@ var _RComplex = class extends RVectorAtomic {
 var RComplex = _RComplex;
 _newSetter4 = new WeakMap();
 __privateAdd(RComplex, _newSetter4, (ptr) => {
-  const data = Module._COMPLEX(ptr);
-  const naDouble = Module.getValue(Module._R_NaReal, "double");
+  const data = Module2._COMPLEX(ptr);
+  const naDouble = Module2.getValue(Module2._R_NaReal, "double");
   return (v, i) => {
-    Module.setValue(data + 8 * (2 * i), v === null ? naDouble : v.re, "double");
-    Module.setValue(data + 8 * (2 * i + 1), v === null ? naDouble : v.im, "double");
+    Module2.setValue(data + 8 * (2 * i), v === null ? naDouble : v.re, "double");
+    Module2.setValue(data + 8 * (2 * i + 1), v === null ? naDouble : v.im, "double");
   };
 });
 var _newSetter5;
@@ -3795,15 +4051,15 @@ var _RCharacter = class extends RVectorAtomic {
   }
   toTypedArray() {
     return new Uint32Array(
-      Module.HEAPU32.subarray(
-        Module._STRING_PTR(this.ptr) / 4,
-        Module._STRING_PTR(this.ptr) / 4 + this.length
+      Module2.HEAPU32.subarray(
+        Module2._STRING_PTR(this.ptr) / 4,
+        Module2._STRING_PTR(this.ptr) / 4 + this.length
       )
     );
   }
   toArray() {
     return this.detectMissing().map(
-      (m, idx) => m ? null : Module.UTF8ToString(Module._R_CHAR(Module._STRING_ELT(this.ptr, idx)))
+      (m, idx) => m ? null : Module2.UTF8ToString(Module2._R_CHAR(Module2._STRING_ELT(this.ptr, idx)))
     );
   }
 };
@@ -3812,9 +4068,9 @@ _newSetter5 = new WeakMap();
 __privateAdd(RCharacter, _newSetter5, (ptr) => {
   return (v, i) => {
     if (v === null) {
-      Module._SET_STRING_ELT(ptr, i, objs.naString.ptr);
+      Module2._SET_STRING_ELT(ptr, i, objs.naString.ptr);
     } else {
-      Module._SET_STRING_ELT(ptr, i, new RString(v).ptr);
+      Module2._SET_STRING_ELT(ptr, i, new RString(v).ptr);
     }
   };
 });
@@ -3838,16 +4094,16 @@ var _RRaw = class extends RVectorAtomic {
   }
   toTypedArray() {
     return new Uint8Array(
-      Module.HEAPU8.subarray(Module._RAW(this.ptr), Module._RAW(this.ptr) + this.length)
+      Module2.HEAPU8.subarray(Module2._RAW(this.ptr), Module2._RAW(this.ptr) + this.length)
     );
   }
 };
 var RRaw = _RRaw;
 _newSetter6 = new WeakMap();
 __privateAdd(RRaw, _newSetter6, (ptr) => {
-  const data = Module._RAW(ptr);
+  const data = Module2._RAW(ptr);
   return (v, i) => {
-    Module.setValue(data + i, Number(v), "i8");
+    Module2.setValue(data + i, Number(v), "i8");
   };
 });
 function toWebRData(jsObj) {
@@ -3894,19 +4150,19 @@ function isRObject(value) {
 var objs;
 function initPersistentObjects() {
   objs = {
-    baseEnv: REnvironment.wrap(Module.getValue(Module._R_BaseEnv, "*")),
-    bracket2Symbol: RSymbol.wrap(Module.getValue(Module._R_Bracket2Symbol, "*")),
-    bracketSymbol: RSymbol.wrap(Module.getValue(Module._R_BracketSymbol, "*")),
-    dollarSymbol: RSymbol.wrap(Module.getValue(Module._R_DollarSymbol, "*")),
-    emptyEnv: REnvironment.wrap(Module.getValue(Module._R_EmptyEnv, "*")),
-    false: RLogical.wrap(Module.getValue(Module._R_FalseValue, "*")),
-    globalEnv: REnvironment.wrap(Module.getValue(Module._R_GlobalEnv, "*")),
-    na: RLogical.wrap(Module.getValue(Module._R_LogicalNAValue, "*")),
-    namesSymbol: RSymbol.wrap(Module.getValue(Module._R_NamesSymbol, "*")),
-    naString: RObject.wrap(Module.getValue(Module._R_NaString, "*")),
-    null: RNull.wrap(Module.getValue(Module._R_NilValue, "*")),
-    true: RLogical.wrap(Module.getValue(Module._R_TrueValue, "*")),
-    unboundValue: RObject.wrap(Module.getValue(Module._R_UnboundValue, "*"))
+    baseEnv: REnvironment.wrap(Module2.getValue(Module2._R_BaseEnv, "*")),
+    bracket2Symbol: RSymbol.wrap(Module2.getValue(Module2._R_Bracket2Symbol, "*")),
+    bracketSymbol: RSymbol.wrap(Module2.getValue(Module2._R_BracketSymbol, "*")),
+    dollarSymbol: RSymbol.wrap(Module2.getValue(Module2._R_DollarSymbol, "*")),
+    emptyEnv: REnvironment.wrap(Module2.getValue(Module2._R_EmptyEnv, "*")),
+    false: RLogical.wrap(Module2.getValue(Module2._R_FalseValue, "*")),
+    globalEnv: REnvironment.wrap(Module2.getValue(Module2._R_GlobalEnv, "*")),
+    na: RLogical.wrap(Module2.getValue(Module2._R_LogicalNAValue, "*")),
+    namesSymbol: RSymbol.wrap(Module2.getValue(Module2._R_NamesSymbol, "*")),
+    naString: RObject.wrap(Module2.getValue(Module2._R_NaString, "*")),
+    null: RNull.wrap(Module2.getValue(Module2._R_NilValue, "*")),
+    true: RLogical.wrap(Module2.getValue(Module2._R_TrueValue, "*")),
+    unboundValue: RObject.wrap(Module2.getValue(Module2._R_UnboundValue, "*"))
   };
 }
 
@@ -3914,16 +4170,20 @@ function initPersistentObjects() {
 var initialised = false;
 var chan;
 var onWorkerMessage = function(msg) {
-  if (!msg || !msg.type || msg.type !== "init") {
+  if (!msg || !msg.type) {
     return;
   }
-  if (initialised) {
-    throw new Error("Can't initialise worker multiple times.");
+  if (msg.type === "init") {
+    if (initialised) {
+      throw new Error("Can't initialise worker multiple times.");
+    }
+    const messageInit = msg;
+    chan = newChannelWorker(messageInit);
+    init(messageInit.data.config);
+    initialised = true;
+    return;
   }
-  const messageInit = msg;
-  chan = newChannelWorker(messageInit);
-  init(messageInit.data.config);
-  initialised = true;
+  chan == null ? void 0 : chan.onMessageFromMainThread(msg);
 };
 if (IN_NODE) {
   require("worker_threads").parentPort.on("message", onWorkerMessage);
@@ -3942,7 +4202,7 @@ function dispatch(msg) {
         switch (reqMsg.type) {
           case "lookupPath": {
             const msg2 = reqMsg;
-            const node = Module.FS.lookupPath(msg2.data.path, {}).node;
+            const node = Module2.FS.lookupPath(msg2.data.path, {}).node;
             write({
               obj: copyFSNode(node),
               payloadType: "raw"
@@ -3952,7 +4212,7 @@ function dispatch(msg) {
           case "mkdir": {
             const msg2 = reqMsg;
             write({
-              obj: copyFSNode(Module.FS.mkdir(msg2.data.path)),
+              obj: copyFSNode(Module2.FS.mkdir(msg2.data.path)),
               payloadType: "raw"
             });
             break;
@@ -3961,7 +4221,7 @@ function dispatch(msg) {
             const msg2 = reqMsg;
             const reqData = msg2.data;
             const out = {
-              obj: Module.FS.readFile(reqData.path, {
+              obj: Module2.FS.readFile(reqData.path, {
                 encoding: "binary",
                 flags: reqData.flags
               }),
@@ -3973,7 +4233,7 @@ function dispatch(msg) {
           case "rmdir": {
             const msg2 = reqMsg;
             write({
-              obj: Module.FS.rmdir(msg2.data.path),
+              obj: Module2.FS.rmdir(msg2.data.path),
               payloadType: "raw"
             });
             break;
@@ -3983,7 +4243,7 @@ function dispatch(msg) {
             const reqData = msg2.data;
             const data = Uint8Array.from(Object.values(reqData.data));
             write({
-              obj: Module.FS.writeFile(reqData.path, data, { flags: reqData.flags }),
+              obj: Module2.FS.writeFile(reqData.path, data, { flags: reqData.flags }),
               payloadType: "raw"
             });
             break;
@@ -3991,7 +4251,7 @@ function dispatch(msg) {
           case "unlink": {
             const msg2 = reqMsg;
             write({
-              obj: Module.FS.unlink(msg2.data.path),
+              obj: Module2.FS.unlink(msg2.data.path),
               payloadType: "raw"
             });
             break;
@@ -4214,7 +4474,7 @@ function dispatch(msg) {
           }
           case "invokeWasmFunction": {
             const msg2 = reqMsg;
-            const res = Module.getWasmTableEntry(msg2.data.ptr)(...msg2.data.args);
+            const res = Module2.getWasmTableEntry(msg2.data.ptr)(...msg2.data.args);
             write({
               payloadType: "raw",
               obj: res
@@ -4243,7 +4503,7 @@ function dispatch(msg) {
           obj: { name: e.name, message: e.message, stack: e.stack }
         });
         if (e instanceof UnwindProtectException) {
-          Module._R_ContinueUnwind(e.cont);
+          Module2._R_ContinueUnwind(e.cont);
           throwUnreachable();
         }
       }
@@ -4371,7 +4631,7 @@ function captureR(code, options = {}) {
     protectInc(fn, prot);
     const codeObj = new RCharacter(code);
     protectInc(codeObj, prot);
-    const call = Module._Rf_lang6(
+    const call = Module2._Rf_lang6(
       fn.ptr,
       codeObj.ptr,
       _options.captureConditions ? tPtr : fPtr,
@@ -4401,7 +4661,7 @@ function captureR(code, options = {}) {
 function evalR(code, options = {}) {
   var _a, _b;
   const capture = captureR(code, options);
-  Module._Rf_protect(capture.ptr);
+  Module2._Rf_protect(capture.ptr);
   try {
     const output = capture.get("output");
     for (let i = 1; i <= output.length; i++) {
@@ -4435,7 +4695,7 @@ ${((_b = out.pluck("data", "message")) == null ? void 0 : _b.toString()) || ""}`
     }
     return capture.get("result");
   } finally {
-    Module._Rf_unprotect(1);
+    Module2._Rf_unprotect(1);
   }
 }
 function init(config) {
@@ -4445,33 +4705,36 @@ function init(config) {
     const fmt = new Intl.DateTimeFormat();
     env.TZ = fmt.resolvedOptions().timeZone;
   }
-  Module.preRun = [];
-  Module.arguments = _config.RArgs;
-  Module.noExitRuntime = true;
-  Module.noImageDecoding = true;
-  Module.noAudioDecoding = true;
-  Module.noInitialRun = true;
-  Module.noWasmDecoding = true;
-  Module.preRun.push(() => {
+  Module2.preRun = [];
+  Module2.arguments = _config.RArgs;
+  Module2.noExitRuntime = true;
+  Module2.noImageDecoding = true;
+  Module2.noAudioDecoding = true;
+  Module2.noInitialRun = true;
+  Module2.noWasmDecoding = true;
+  Module2.preRun.push(() => {
     if (IN_NODE) {
-      globalThis.FS = Module.FS;
+      globalThis.FS = Module2.FS;
+      globalThis.chan = chan;
+    }
+    if (_config.createLazyFilesystem) {
+      Module2.createLazyFilesystem();
     }
-    Module.createLazyFilesystem();
-    Module.FS.mkdirTree(_config.homedir);
-    Module.ENV.HOME = _config.homedir;
-    Module.FS.chdir(_config.homedir);
-    Module.ENV = Object.assign(Module.ENV, env);
+    Module2.FS.mkdirTree(_config.homedir);
+    Module2.ENV.HOME = _config.homedir;
+    Module2.FS.chdir(_config.homedir);
+    Module2.ENV = Object.assign(Module2.ENV, env);
   });
   chan == null ? void 0 : chan.setDispatchHandler(dispatch);
-  Module.onRuntimeInitialized = () => {
+  Module2.onRuntimeInitialized = () => {
     chan == null ? void 0 : chan.run(_config.RArgs);
   };
-  Module.webr = {
+  Module2.webr = {
     UnwindProtectException,
     resolveInit: () => {
       initPersistentObjects();
-      chan == null ? void 0 : chan.setInterrupt(Module._Rf_onintr);
-      Module.setValue(Module._R_Interactive, _config.interactive, "*");
+      chan == null ? void 0 : chan.setInterrupt(Module2._Rf_onintr);
+      Module2.setValue(Module2._R_Interactive, _config.interactive, "*");
       evalR(`options(webr_pkg_repos="${_config.repoUrl}")`);
       chan == null ? void 0 : chan.resolve();
     },
@@ -4486,19 +4749,19 @@ function init(config) {
     },
     evalJs: (code) => {
       try {
-        return (0, eval)(Module.UTF8ToString(code));
+        return (0, eval)(Module2.UTF8ToString(code));
       } catch (e) {
         if (e instanceof UnwindProtectException) {
-          Module._R_ContinueUnwind(e.cont);
+          Module2._R_ContinueUnwind(e.cont);
           throwUnreachable();
         } else if (e === Infinity) {
           throw e;
         }
-        const msg = Module.allocateUTF8OnStack(
+        const msg = Module2.allocateUTF8OnStack(
           `An error occured during JavaScript evaluation:
   ${e.message}`
         );
-        Module._Rf_error(msg);
+        Module2._Rf_error(msg);
       }
       throwUnreachable();
       return 0;
@@ -4507,21 +4770,18 @@ function init(config) {
       chan == null ? void 0 : chan.writeSystem({ type: "setTimeoutWasm", data: { ptr, delay, args } });
     }
   };
-  Module.locateFile = (path) => _config.baseUrl + path;
-  Module.downloadFileContent = downloadFileContent;
-  Module.print = (text) => {
+  Module2.locateFile = (path) => _config.baseUrl + path;
+  Module2.downloadFileContent = downloadFileContent;
+  Module2.print = (text) => {
     chan == null ? void 0 : chan.write({ type: "stdout", data: text });
   };
-  Module.printErr = (text) => {
+  Module2.printErr = (text) => {
     chan == null ? void 0 : chan.write({ type: "stderr", data: text });
   };
-  Module.setPrompt = (prompt) => {
+  Module2.setPrompt = (prompt) => {
     chan == null ? void 0 : chan.write({ type: "prompt", data: prompt });
   };
-  Module.canvasExec = (op) => {
-    chan == null ? void 0 : chan.write({ type: "canvasExec", data: op });
-  };
-  globalThis.Module = Module;
+  globalThis.Module = Module2;
   setTimeout(() => {
     const scriptSrc = `${_config.baseUrl}R.bin.js`;
     loadScript(scriptSrc);