@php-wasm/node 0.6.3 → 0.6.4

package/php_8_1.js

@@ -1,6 +1,6 @@
 const dependencyFilename = __dirname + '/8_1_23/php_8_1.wasm'; 
 export { dependencyFilename }; 
-export const dependenciesTotalSize = 10994159; 
+export const dependenciesTotalSize = 10993532; 
 export function init(RuntimeName, PHPLoader) {
     /**
      * Overrides Emscripten's default ExitStatus object which gets
@@ -1475,6 +1475,216 @@ var NODEFS = {
  }
 };
 
+var PROXYFS = {
+ mount(mount) {
+  return PROXYFS.createNode(null, "/", mount.opts.fs.lstat(mount.opts.root).mode, 0);
+ },
+ createNode(parent, name, mode, dev) {
+  if (!FS.isDir(mode) && !FS.isFile(mode) && !FS.isLink(mode)) {
+   throw new FS.ErrnoError(ERRNO_CODES.EINVAL);
+  }
+  var node = FS.createNode(parent, name, mode);
+  node.node_ops = PROXYFS.node_ops;
+  node.stream_ops = PROXYFS.stream_ops;
+  return node;
+ },
+ realPath(node) {
+  var parts = [];
+  while (node.parent !== node) {
+   parts.push(node.name);
+   node = node.parent;
+  }
+  parts.push(node.mount.opts.root);
+  parts.reverse();
+  return PATH.join.apply(null, parts);
+ },
+ node_ops: {
+  getattr(node) {
+   var path = PROXYFS.realPath(node);
+   var stat;
+   try {
+    stat = node.mount.opts.fs.lstat(path);
+   } catch (e) {
+    if (!e.code) throw e;
+    throw new FS.ErrnoError(ERRNO_CODES[e.code]);
+   }
+   return {
+    dev: stat.dev,
+    ino: stat.ino,
+    mode: stat.mode,
+    nlink: stat.nlink,
+    uid: stat.uid,
+    gid: stat.gid,
+    rdev: stat.rdev,
+    size: stat.size,
+    atime: stat.atime,
+    mtime: stat.mtime,
+    ctime: stat.ctime,
+    blksize: stat.blksize,
+    blocks: stat.blocks
+   };
+  },
+  setattr(node, attr) {
+   var path = PROXYFS.realPath(node);
+   try {
+    if (attr.mode !== undefined) {
+     node.mount.opts.fs.chmod(path, attr.mode);
+     node.mode = attr.mode;
+    }
+    if (attr.timestamp !== undefined) {
+     var date = new Date(attr.timestamp);
+     node.mount.opts.fs.utime(path, date, date);
+    }
+    if (attr.size !== undefined) {
+     node.mount.opts.fs.truncate(path, attr.size);
+    }
+   } catch (e) {
+    if (!e.code) throw e;
+    throw new FS.ErrnoError(ERRNO_CODES[e.code]);
+   }
+  },
+  lookup(parent, name) {
+   try {
+    var path = PATH.join2(PROXYFS.realPath(parent), name);
+    var mode = parent.mount.opts.fs.lstat(path).mode;
+    var node = PROXYFS.createNode(parent, name, mode);
+    return node;
+   } catch (e) {
+    if (!e.code) throw e;
+    throw new FS.ErrnoError(ERRNO_CODES[e.code]);
+   }
+  },
+  mknod(parent, name, mode, dev) {
+   var node = PROXYFS.createNode(parent, name, mode, dev);
+   var path = PROXYFS.realPath(node);
+   try {
+    if (FS.isDir(node.mode)) {
+     node.mount.opts.fs.mkdir(path, node.mode);
+    } else {
+     node.mount.opts.fs.writeFile(path, "", {
+      mode: node.mode
+     });
+    }
+   } catch (e) {
+    if (!e.code) throw e;
+    throw new FS.ErrnoError(ERRNO_CODES[e.code]);
+   }
+   return node;
+  },
+  rename(oldNode, newDir, newName) {
+   var oldPath = PROXYFS.realPath(oldNode);
+   var newPath = PATH.join2(PROXYFS.realPath(newDir), newName);
+   try {
+    oldNode.mount.opts.fs.rename(oldPath, newPath);
+    oldNode.name = newName;
+    oldNode.parent = newDir;
+   } catch (e) {
+    if (!e.code) throw e;
+    throw new FS.ErrnoError(ERRNO_CODES[e.code]);
+   }
+  },
+  unlink(parent, name) {
+   var path = PATH.join2(PROXYFS.realPath(parent), name);
+   try {
+    parent.mount.opts.fs.unlink(path);
+   } catch (e) {
+    if (!e.code) throw e;
+    throw new FS.ErrnoError(ERRNO_CODES[e.code]);
+   }
+  },
+  rmdir(parent, name) {
+   var path = PATH.join2(PROXYFS.realPath(parent), name);
+   try {
+    parent.mount.opts.fs.rmdir(path);
+   } catch (e) {
+    if (!e.code) throw e;
+    throw new FS.ErrnoError(ERRNO_CODES[e.code]);
+   }
+  },
+  readdir(node) {
+   var path = PROXYFS.realPath(node);
+   try {
+    return node.mount.opts.fs.readdir(path);
+   } catch (e) {
+    if (!e.code) throw e;
+    throw new FS.ErrnoError(ERRNO_CODES[e.code]);
+   }
+  },
+  symlink(parent, newName, oldPath) {
+   var newPath = PATH.join2(PROXYFS.realPath(parent), newName);
+   try {
+    parent.mount.opts.fs.symlink(oldPath, newPath);
+   } catch (e) {
+    if (!e.code) throw e;
+    throw new FS.ErrnoError(ERRNO_CODES[e.code]);
+   }
+  },
+  readlink(node) {
+   var path = PROXYFS.realPath(node);
+   try {
+    return node.mount.opts.fs.readlink(path);
+   } catch (e) {
+    if (!e.code) throw e;
+    throw new FS.ErrnoError(ERRNO_CODES[e.code]);
+   }
+  }
+ },
+ stream_ops: {
+  open(stream) {
+   var path = PROXYFS.realPath(stream.node);
+   try {
+    stream.nfd = stream.node.mount.opts.fs.open(path, stream.flags);
+   } catch (e) {
+    if (!e.code) throw e;
+    throw new FS.ErrnoError(ERRNO_CODES[e.code]);
+   }
+  },
+  close(stream) {
+   try {
+    stream.node.mount.opts.fs.close(stream.nfd);
+   } catch (e) {
+    if (!e.code) throw e;
+    throw new FS.ErrnoError(ERRNO_CODES[e.code]);
+   }
+  },
+  read(stream, buffer, offset, length, position) {
+   try {
+    return stream.node.mount.opts.fs.read(stream.nfd, buffer, offset, length, position);
+   } catch (e) {
+    if (!e.code) throw e;
+    throw new FS.ErrnoError(ERRNO_CODES[e.code]);
+   }
+  },
+  write(stream, buffer, offset, length, position) {
+   try {
+    return stream.node.mount.opts.fs.write(stream.nfd, buffer, offset, length, position);
+   } catch (e) {
+    if (!e.code) throw e;
+    throw new FS.ErrnoError(ERRNO_CODES[e.code]);
+   }
+  },
+  llseek(stream, offset, whence) {
+   var position = offset;
+   if (whence === 1) {
+    position += stream.position;
+   } else if (whence === 2) {
+    if (FS.isFile(stream.node.mode)) {
+     try {
+      var stat = stream.node.node_ops.getattr(stream.node);
+      position += stat.size;
+     } catch (e) {
+      throw new FS.ErrnoError(ERRNO_CODES[e.code]);
+     }
+    }
+   }
+   if (position < 0) {
+    throw new FS.ErrnoError(ERRNO_CODES.EINVAL);
+   }
+   return position;
+  }
+ }
+};
+
 var FS = {
  root: null,
  mounts: [],
@@ -2550,7 +2760,8 @@ var FS = {
   FS.createSpecialDirectories();
   FS.filesystems = {
    "MEMFS": MEMFS,
-   "NODEFS": NODEFS
+   "NODEFS": NODEFS,
+   "PROXYFS": PROXYFS
   };
  },
  init: (input, output, error) => {
@@ -5427,6 +5638,7 @@ var allocateUTF8OnStack = stringToUTF8OnStack;
 
 var PHPWASM = {
  init: function() {
+  FS.mkdir("/internal");
   PHPWASM.EventEmitter = ENVIRONMENT_IS_NODE ? require("events").EventEmitter : class EventEmitter {
    constructor() {
     this.listeners = {};
@@ -5531,9 +5743,9 @@ var PHPWASM = {
   return [ promise, cancel ];
  },
  noop: function() {},
- spawnProcess: function(command, args) {
+ spawnProcess: function(command, args, options) {
   if (Module["spawnProcess"]) {
-   const spawnedPromise = Module["spawnProcess"](command, args);
+   const spawnedPromise = Module["spawnProcess"](command, args, options);
    return Promise.resolve(spawnedPromise).then((function(spawned) {
     if (!spawned || !spawned.on) {
      throw new Error("spawnProcess() must return an EventEmitter but returned a different type.");
@@ -5542,7 +5754,8 @@ var PHPWASM = {
    }));
   }
   if (ENVIRONMENT_IS_NODE) {
-   return require("child_process").spawn(command, [], {
+   return require("child_process").spawn(command, args, {
+    ...options,
     shell: true,
     stdio: [ "pipe", "pipe", "pipe" ],
     timeout: 100
@@ -5600,48 +5813,59 @@ function _js_create_input_device(deviceId) {
 }
 
 function _js_fd_read(fd, iov, iovcnt, pnum) {
- var returnCode;
- var stream;
- try {
-  stream = SYSCALLS.getStreamFromFD(fd);
-  var num = doReadv(stream, iov, iovcnt);
-  HEAPU32[pnum >> 2] = num;
-  returnCode = 0;
- } catch (e) {
-  if (typeof FS == "undefined" || !(e.name === "ErrnoError")) throw e;
-  returnCode = e.errno;
+ if (Asyncify.state === Asyncify.State.Normal) {
+  var returnCode;
+  var stream;
+  let num = 0;
+  try {
+   stream = SYSCALLS.getStreamFromFD(fd);
+   const num = doReadv(stream, iov, iovcnt);
+   HEAPU32[pnum >> 2] = num;
+   return 0;
+  } catch (e) {
+   if (typeof FS == "undefined" || !(e.name === "ErrnoError")) {
+    throw e;
+   }
+   if (e.errno !== 6 || !(stream?.fd in PHPWASM.child_proc_by_fd)) {
+    HEAPU32[pnum >> 2] = 0;
+    return returnCode;
+   }
+  }
  }
- if (returnCode === 6 && stream?.fd in PHPWASM.child_proc_by_fd) {
-  return Asyncify.handleSleep((function(wakeUp) {
-   var retries = 0;
-   var interval = 50;
-   var timeout = 5e3;
-   var maxRetries = timeout / interval;
-   function poll() {
-    var returnCode;
-    var stream;
-    try {
-     stream = SYSCALLS.getStreamFromFD(fd);
-     var num = doReadv(stream, iov, iovcnt);
-     HEAPU32[pnum >> 2] = num;
-     returnCode = 0;
-    } catch (e) {
-     if (typeof FS == "undefined" || !(e.name === "ErrnoError")) {
-      console.error(e);
-      throw e;
-     }
-     returnCode = e.errno;
-    }
-    if (returnCode !== 6 || ++retries > maxRetries || !(fd in PHPWASM.child_proc_by_fd) || PHPWASM.child_proc_by_fd[fd]?.exited || FS.isClosed(stream)) {
-     wakeUp(returnCode);
-    } else {
-     setTimeout(poll, interval);
+ return Asyncify.handleSleep((function(wakeUp) {
+  var retries = 0;
+  var interval = 50;
+  var timeout = 5e3;
+  var maxRetries = timeout / interval;
+  function poll() {
+   var returnCode;
+   var stream;
+   let num;
+   try {
+    stream = SYSCALLS.getStreamFromFD(fd);
+    num = doReadv(stream, iov, iovcnt);
+    returnCode = 0;
+   } catch (e) {
+    if (typeof FS == "undefined" || !(e.name === "ErrnoError")) {
+     console.error(e);
+     throw e;
     }
+    returnCode = e.errno;
    }
-   poll();
-  }));
- }
- return returnCode;
+   const success = returnCode === 0;
+   const failure = ++retries > maxRetries || !(fd in PHPWASM.child_proc_by_fd) || PHPWASM.child_proc_by_fd[fd]?.exited || FS.isClosed(stream);
+   if (success) {
+    HEAPU32[pnum >> 2] = num;
+    wakeUp(0);
+   } else if (failure) {
+    HEAPU32[pnum >> 2] = 0;
+    wakeUp(returnCode === 6 ? 0 : returnCode);
+   } else {
+    setTimeout(poll, interval);
+   }
+  }
+  poll();
+ }));
 }
 
 function _js_module_onMessage(data, bufPtr) {
@@ -5670,7 +5894,7 @@ function _js_module_onMessage(data, bufPtr) {
  }
 }
 
-function _js_open_process(command, argsPtr, argsLength, descriptorsPtr, descriptorsLength) {
+function _js_open_process(command, argsPtr, argsLength, descriptorsPtr, descriptorsLength, cwdPtr, cwdLength, envPtr, envLength) {
  if (!command) {
   return 1;
  }
@@ -5685,6 +5909,22 @@ function _js_open_process(command, argsPtr, argsLength, descriptorsPtr, descript
    argsArray.push(UTF8ToString(HEAPU32[charPointer >> 2]));
   }
  }
+ const cwdstr = cwdPtr ? UTF8ToString(cwdPtr) : null;
+ let envObject = null;
+ if (envLength) {
+  envObject = {};
+  for (var i = 0; i < envLength; i++) {
+   const envPointer = envPtr + i * 4;
+   const envEntry = UTF8ToString(HEAPU32[envPointer >> 2]);
+   const splitAt = envEntry.indexOf("=");
+   if (splitAt === -1) {
+    continue;
+   }
+   const key = envEntry.substring(0, splitAt);
+   const value = envEntry.substring(splitAt + 1);
+   envObject[key] = value;
+  }
+ }
  var std = {};
  for (var i = 0; i < descriptorsLength; i++) {
   const descriptorPtr = HEAPU32[descriptorsPtr + i * 4 >> 2];
@@ -5696,7 +5936,14 @@ function _js_open_process(command, argsPtr, argsLength, descriptorsPtr, descript
  return Asyncify.handleSleep((async wakeUp => {
   let cp;
   try {
-   cp = PHPWASM.spawnProcess(cmdstr, argsArray);
+   const options = {};
+   if (cwdstr !== null) {
+    options.cwd = cwdstr;
+   }
+   if (envObject !== null) {
+    options.env = envObject;
+   }
+   cp = PHPWASM.spawnProcess(cmdstr, argsArray, options);
    if (cp instanceof Promise) {
     cp = await cp;
    }
@@ -5841,11 +6088,12 @@ function _js_popen_to_file(command, mode, exitCodePtr) {
  }));
 }
 
-function _js_process_status(pid) {
+function _js_process_status(pid, exitCodePtr) {
  if (!PHPWASM.child_proc_by_pid[pid]) {
   return -1;
  }
  if (PHPWASM.child_proc_by_pid[pid].exited) {
+  HEAPU32[exitCodePtr >> 2] = PHPWASM.child_proc_by_pid[pid].exitCode;
   return 1;
  }
  return 0;
@@ -5858,8 +6106,8 @@ function _js_waitpid(pid, exitCodePtr) {
  return Asyncify.handleSleep((wakeUp => {
   const poll = function() {
    if (PHPWASM.child_proc_by_pid[pid]?.exited) {
-    HEAPU8[exitCodePtr] = PHPWASM.child_proc_by_pid[pid].exitCode;
-    wakeUp(0);
+    HEAPU32[exitCodePtr >> 2] = PHPWASM.child_proc_by_pid[pid].exitCode;
+    wakeUp(pid);
    } else {
     setTimeout(poll, 50);
    }
@@ -7063,8 +7311,8 @@ var _wasm_add_SERVER_entry = Module["_wasm_add_SERVER_entry"] = function() {
  return (_wasm_add_SERVER_entry = Module["_wasm_add_SERVER_entry"] = Module["asm"]["zb"]).apply(null, arguments);
 };
 
-var _wasm_add_uploaded_file = Module["_wasm_add_uploaded_file"] = function() {
- return (_wasm_add_uploaded_file = Module["_wasm_add_uploaded_file"] = Module["asm"]["Ab"]).apply(null, arguments);
+var _wasm_add_ENV_entry = Module["_wasm_add_ENV_entry"] = function() {
+ return (_wasm_add_ENV_entry = Module["_wasm_add_ENV_entry"] = Module["asm"]["Ab"]).apply(null, arguments);
 };
 
 var _wasm_set_query_string = Module["_wasm_set_query_string"] = function() {
@@ -7115,40 +7363,28 @@ var _wasm_set_request_port = Module["_wasm_set_request_port"] = function() {
  return (_wasm_set_request_port = Module["_wasm_set_request_port"] = Module["asm"]["Mb"]).apply(null, arguments);
 };
 
-var _phpwasm_init_uploaded_files_hash = Module["_phpwasm_init_uploaded_files_hash"] = function() {
- return (_phpwasm_init_uploaded_files_hash = Module["_phpwasm_init_uploaded_files_hash"] = Module["asm"]["Nb"]).apply(null, arguments);
-};
-
-var _phpwasm_register_uploaded_file = Module["_phpwasm_register_uploaded_file"] = function() {
- return (_phpwasm_register_uploaded_file = Module["_phpwasm_register_uploaded_file"] = Module["asm"]["Ob"]).apply(null, arguments);
-};
-
-var _phpwasm_destroy_uploaded_files_hash = Module["_phpwasm_destroy_uploaded_files_hash"] = function() {
- return (_phpwasm_destroy_uploaded_files_hash = Module["_phpwasm_destroy_uploaded_files_hash"] = Module["asm"]["Pb"]).apply(null, arguments);
-};
-
 var _wasm_sapi_handle_request = Module["_wasm_sapi_handle_request"] = function() {
- return (_wasm_sapi_handle_request = Module["_wasm_sapi_handle_request"] = Module["asm"]["Qb"]).apply(null, arguments);
+ return (_wasm_sapi_handle_request = Module["_wasm_sapi_handle_request"] = Module["asm"]["Nb"]).apply(null, arguments);
 };
 
 var _php_wasm_init = Module["_php_wasm_init"] = function() {
- return (_php_wasm_init = Module["_php_wasm_init"] = Module["asm"]["Rb"]).apply(null, arguments);
+ return (_php_wasm_init = Module["_php_wasm_init"] = Module["asm"]["Ob"]).apply(null, arguments);
 };
 
 var ___funcs_on_exit = function() {
- return (___funcs_on_exit = Module["asm"]["Sb"]).apply(null, arguments);
+ return (___funcs_on_exit = Module["asm"]["Pb"]).apply(null, arguments);
 };
 
 var _emscripten_builtin_memalign = function() {
- return (_emscripten_builtin_memalign = Module["asm"]["Tb"]).apply(null, arguments);
+ return (_emscripten_builtin_memalign = Module["asm"]["Qb"]).apply(null, arguments);
 };
 
 var __emscripten_timeout = function() {
- return (__emscripten_timeout = Module["asm"]["Ub"]).apply(null, arguments);
+ return (__emscripten_timeout = Module["asm"]["Rb"]).apply(null, arguments);
 };
 
 var _setThrew = function() {
- return (_setThrew = Module["asm"]["Vb"]).apply(null, arguments);
+ return (_setThrew = Module["asm"]["Sb"]).apply(null, arguments);
 };
 
 var _emscripten_stack_set_limits = function() {
@@ -7164,107 +7400,107 @@ var _emscripten_stack_get_end = function() {
 };
 
 var stackSave = function() {
- return (stackSave = Module["asm"]["Wb"]).apply(null, arguments);
+ return (stackSave = Module["asm"]["Tb"]).apply(null, arguments);
 };
 
 var stackRestore = function() {
- return (stackRestore = Module["asm"]["Xb"]).apply(null, arguments);
+ return (stackRestore = Module["asm"]["Ub"]).apply(null, arguments);
 };
 
 var stackAlloc = function() {
- return (stackAlloc = Module["asm"]["Yb"]).apply(null, arguments);
+ return (stackAlloc = Module["asm"]["Vb"]).apply(null, arguments);
 };
 
 var dynCall_iiii = Module["dynCall_iiii"] = function() {
- return (dynCall_iiii = Module["dynCall_iiii"] = Module["asm"]["Zb"]).apply(null, arguments);
+ return (dynCall_iiii = Module["dynCall_iiii"] = Module["asm"]["Wb"]).apply(null, arguments);
 };
 
 var dynCall_ii = Module["dynCall_ii"] = function() {
- return (dynCall_ii = Module["dynCall_ii"] = Module["asm"]["_b"]).apply(null, arguments);
+ return (dynCall_ii = Module["dynCall_ii"] = Module["asm"]["Xb"]).apply(null, arguments);
 };
 
 var dynCall_vi = Module["dynCall_vi"] = function() {
- return (dynCall_vi = Module["dynCall_vi"] = Module["asm"]["$b"]).apply(null, arguments);
+ return (dynCall_vi = Module["dynCall_vi"] = Module["asm"]["Yb"]).apply(null, arguments);
 };
 
 var dynCall_vii = Module["dynCall_vii"] = function() {
- return (dynCall_vii = Module["dynCall_vii"] = Module["asm"]["ac"]).apply(null, arguments);
+ return (dynCall_vii = Module["dynCall_vii"] = Module["asm"]["Zb"]).apply(null, arguments);
 };
 
 var dynCall_viiiii = Module["dynCall_viiiii"] = function() {
- return (dynCall_viiiii = Module["dynCall_viiiii"] = Module["asm"]["bc"]).apply(null, arguments);
+ return (dynCall_viiiii = Module["dynCall_viiiii"] = Module["asm"]["_b"]).apply(null, arguments);
 };
 
 var dynCall_iii = Module["dynCall_iii"] = function() {
- return (dynCall_iii = Module["dynCall_iii"] = Module["asm"]["cc"]).apply(null, arguments);
+ return (dynCall_iii = Module["dynCall_iii"] = Module["asm"]["$b"]).apply(null, arguments);
 };
 
 var dynCall_iiiii = Module["dynCall_iiiii"] = function() {
- return (dynCall_iiiii = Module["dynCall_iiiii"] = Module["asm"]["dc"]).apply(null, arguments);
+ return (dynCall_iiiii = Module["dynCall_iiiii"] = Module["asm"]["ac"]).apply(null, arguments);
 };
 
 var dynCall_iiiiii = Module["dynCall_iiiiii"] = function() {
- return (dynCall_iiiiii = Module["dynCall_iiiiii"] = Module["asm"]["ec"]).apply(null, arguments);
+ return (dynCall_iiiiii = Module["dynCall_iiiiii"] = Module["asm"]["bc"]).apply(null, arguments);
 };
 
 var dynCall_viii = Module["dynCall_viii"] = function() {
- return (dynCall_viii = Module["dynCall_viii"] = Module["asm"]["fc"]).apply(null, arguments);
+ return (dynCall_viii = Module["dynCall_viii"] = Module["asm"]["cc"]).apply(null, arguments);
 };
 
 var dynCall_v = Module["dynCall_v"] = function() {
- return (dynCall_v = Module["dynCall_v"] = Module["asm"]["gc"]).apply(null, arguments);
+ return (dynCall_v = Module["dynCall_v"] = Module["asm"]["dc"]).apply(null, arguments);
 };
 
 var dynCall_i = Module["dynCall_i"] = function() {
- return (dynCall_i = Module["dynCall_i"] = Module["asm"]["hc"]).apply(null, arguments);
+ return (dynCall_i = Module["dynCall_i"] = Module["asm"]["ec"]).apply(null, arguments);
 };
 
 var dynCall_viiii = Module["dynCall_viiii"] = function() {
- return (dynCall_viiii = Module["dynCall_viiii"] = Module["asm"]["ic"]).apply(null, arguments);
+ return (dynCall_viiii = Module["dynCall_viiii"] = Module["asm"]["fc"]).apply(null, arguments);
 };
 
 var dynCall_iiiiiii = Module["dynCall_iiiiiii"] = function() {
- return (dynCall_iiiiiii = Module["dynCall_iiiiiii"] = Module["asm"]["jc"]).apply(null, arguments);
+ return (dynCall_iiiiiii = Module["dynCall_iiiiiii"] = Module["asm"]["gc"]).apply(null, arguments);
 };
 
 var dynCall_viiiiiiiii = Module["dynCall_viiiiiiiii"] = function() {
- return (dynCall_viiiiiiiii = Module["dynCall_viiiiiiiii"] = Module["asm"]["kc"]).apply(null, arguments);
+ return (dynCall_viiiiiiiii = Module["dynCall_viiiiiiiii"] = Module["asm"]["hc"]).apply(null, arguments);
 };
 
 var dynCall_viiiiiii = Module["dynCall_viiiiiii"] = function() {
- return (dynCall_viiiiiii = Module["dynCall_viiiiiii"] = Module["asm"]["lc"]).apply(null, arguments);
+ return (dynCall_viiiiiii = Module["dynCall_viiiiiii"] = Module["asm"]["ic"]).apply(null, arguments);
 };
 
 var dynCall_viiiiii = Module["dynCall_viiiiii"] = function() {
- return (dynCall_viiiiii = Module["dynCall_viiiiii"] = Module["asm"]["mc"]).apply(null, arguments);
+ return (dynCall_viiiiii = Module["dynCall_viiiiii"] = Module["asm"]["jc"]).apply(null, arguments);
 };
 
 var dynCall_iiiiiiii = Module["dynCall_iiiiiiii"] = function() {
- return (dynCall_iiiiiiii = Module["dynCall_iiiiiiii"] = Module["asm"]["nc"]).apply(null, arguments);
+ return (dynCall_iiiiiiii = Module["dynCall_iiiiiiii"] = Module["asm"]["kc"]).apply(null, arguments);
 };
 
 var dynCall_iiiiiiiiii = Module["dynCall_iiiiiiiiii"] = function() {
- return (dynCall_iiiiiiiiii = Module["dynCall_iiiiiiiiii"] = Module["asm"]["oc"]).apply(null, arguments);
+ return (dynCall_iiiiiiiiii = Module["dynCall_iiiiiiiiii"] = Module["asm"]["lc"]).apply(null, arguments);
 };
 
 var dynCall_viidii = Module["dynCall_viidii"] = function() {
- return (dynCall_viidii = Module["dynCall_viidii"] = Module["asm"]["pc"]).apply(null, arguments);
+ return (dynCall_viidii = Module["dynCall_viidii"] = Module["asm"]["mc"]).apply(null, arguments);
 };
 
 var _asyncify_start_unwind = function() {
- return (_asyncify_start_unwind = Module["asm"]["qc"]).apply(null, arguments);
+ return (_asyncify_start_unwind = Module["asm"]["nc"]).apply(null, arguments);
 };
 
 var _asyncify_stop_unwind = function() {
- return (_asyncify_stop_unwind = Module["asm"]["rc"]).apply(null, arguments);
+ return (_asyncify_stop_unwind = Module["asm"]["oc"]).apply(null, arguments);
 };
 
 var _asyncify_start_rewind = function() {
- return (_asyncify_start_rewind = Module["asm"]["sc"]).apply(null, arguments);
+ return (_asyncify_start_rewind = Module["asm"]["pc"]).apply(null, arguments);
 };
 
 var _asyncify_stop_rewind = function() {
- return (_asyncify_stop_rewind = Module["asm"]["tc"]).apply(null, arguments);
+ return (_asyncify_stop_rewind = Module["asm"]["qc"]).apply(null, arguments);
 };
 
 function invoke_iiiiiii(index, a1, a2, a3, a4, a5, a6) {
@@ -7494,6 +7730,8 @@ Module["ccall"] = ccall;
 
 Module["FS_createPreloadedFile"] = FS.createPreloadedFile;
 
+Module["PROXYFS"] = PROXYFS;
+
 var calledRun;
 
 dependenciesFulfilled = function runCaller() {