https://arxtect.github.io/stellar-latex/stellarlatexpdftex.js

1099    },
1100    close(stream) {
1101      stream.tty.ops.fsync(stream.tty);
1102    },
1103    fsync(stream) {
1104      stream.tty.ops.fsync(stream.tty);
1105    },
1106    read(stream, buffer, offset, length, pos) {
1107      if (!stream.tty || !stream.tty.ops.get_char) {
1108        throw new FS.ErrnoError(60);
1109      }
1110      var bytesRead = 0;
1111      for (var i = 0; i < length; i++) {
1112        var result;
1113        try {
1114          result = stream.tty.ops.get_char(stream.tty);
1115        } catch (e) {
1116          throw new FS.ErrnoError(29);
1117        }
1118        if (result === undefined && bytesRead === 0) {
1119          throw new FS.ErrnoError(6);
1120        }
1121        if (result === null || result === undefined) break;
1122        bytesRead++;
1123        buffer[offset + i] = result;
1124      }
1125      if (bytesRead) {
1126        stream.node.atime = Date.now();
1127      }
1128      return bytesRead;
1129    },
1130    write(stream, buffer, offset, length, pos) {
1131      if (!stream.tty || !stream.tty.ops.put_char) {
1132        throw new FS.ErrnoError(60);
1133      }
1134      try {
1135        for (var i = 0; i < length; i++) {
1136          stream.tty.ops.put_char(stream.tty, buffer[offset + i]);
1137        }
1138      } catch (e) {
1139        throw new FS.ErrnoError(29);
1140      }
1141      if (length) {
1142        stream.node.mtime = stream.node.ctime = Date.now();
1143      }
1144      return i;
1145    },
1146  },
1147  default_tty_ops: {
1148    get_char(tty) {
1149      return FS_stdin_getChar();
1150    },
1151    put_char(tty, val) {
1152      if (val === null || val === 10) {
1153        out(UTF8ArrayToString(tty.output));
1154        tty.output = [];
1155      } else {
1156        if (val != 0) tty.output.push(val);
1157      }
1158    },
1159    fsync(tty) {
1160      if (tty.output?.length > 0) {
1161        out(UTF8ArrayToString(tty.output));
1162        tty.output = [];
1163      }
1164    },
1165    ioctl_tcgets(tty) {
1166      return {
1167        c_iflag: 25856,
1168        c_oflag: 5,
1169        c_cflag: 191,
1170        c_lflag: 35387,
1171        c_cc: [
1172          3, 28, 127, 21, 4, 0, 1, 0, 17, 19, 26, 0, 18, 15, 23, 22, 0, 0, 0, 0,
1173          0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
1174        ],
1175      };
1176    },
1177    ioctl_tcsets(tty, optional_actions, data) {
1178      return 0;
1179    },
1180    ioctl_tiocgwinsz(tty) {
1181      return [24, 80];
1182    },
1183  },
1184  default_tty1_ops: {
1185    put_char(tty, val) {
1186      if (val === null || val === 10) {
1187        err(UTF8ArrayToString(tty.output));
1188        tty.output = [];
1189      } else {
1190        if (val != 0) tty.output.push(val);
1191      }
1192    },
1193    fsync(tty) {
1194      if (tty.output?.length > 0) {
1195        err(UTF8ArrayToString(tty.output));
1196        tty.output = [];
1197      }
1198    },
1199  },
1200};
1201var alignMemory = (size, alignment) => Math.ceil(size / alignment) * alignment;
1202var mmapAlloc = (size) => {
1203  abort();
1204};
1205var MEMFS = {
1206  ops_table: null,
1207  mount(mount) {
1208    return MEMFS.createNode(null, "/", 16895, 0);
1209  },
1210  createNode(parent, name, mode, dev) {
1211    if (FS.isBlkdev(mode) || FS.isFIFO(mode)) {
1212      throw new FS.ErrnoError(63);
1213    }
1214    MEMFS.ops_table ||= {
1215      dir: {
1216        node: {
1217          getattr: MEMFS.node_ops.getattr,
1218          setattr: MEMFS.node_ops.setattr,
1219          lookup: MEMFS.node_ops.lookup,
1220          mknod: MEMFS.node_ops.mknod,
1221          rename: MEMFS.node_ops.rename,
1222          unlink: MEMFS.node_ops.unlink,
1223          rmdir: MEMFS.node_ops.rmdir,
1224          readdir: MEMFS.node_ops.readdir,
1225          symlink: MEMFS.node_ops.symlink,
1226        },
1227        stream: { llseek: MEMFS.stream_ops.llseek },
1228      },
1229      file: {
1230        node: {
1231          getattr: MEMFS.node_ops.getattr,
1232          setattr: MEMFS.node_ops.setattr,
1233        },
1234        stream: {
1235          llseek: MEMFS.stream_ops.llseek,
1236          read: MEMFS.stream_ops.read,
1237          write: MEMFS.stream_ops.write,
1238          allocate: MEMFS.stream_ops.allocate,
1239          mmap: MEMFS.stream_ops.mmap,
1240          msync: MEMFS.stream_ops.msync,
1241        },
1242      },
1243      link: {
1244        node: {
1245          getattr: MEMFS.node_ops.getattr,
1246          setattr: MEMFS.node_ops.setattr,
1247          readlink: MEMFS.node_ops.readlink,
1248        },
1249        stream: {},
1250      },
1251      chrdev: {
1252        node: {
1253          getattr: MEMFS.node_ops.getattr,
1254          setattr: MEMFS.node_ops.setattr,
1255        },
1256        stream: FS.chrdev_stream_ops,
1257      },
1258    };
1259    var node = FS.createNode(parent, name, mode, dev);
1260    if (FS.isDir(node.mode)) {
1261      node.node_ops = MEMFS.ops_table.dir.node;
1262      node.stream_ops = MEMFS.ops_table.dir.stream;
1263      node.contents = {};
1264    } else if (FS.isFile(node.mode)) {

1265      node.node_ops = MEMFS.ops_table.file.node;
1266      node.stream_ops = MEMFS.ops_table.file.stream;
1267      node.usedBytes = 0;
1268      node.contents = null;
1269    } else if (FS.isLink(node.mode)) {
1270      node.node_ops = MEMFS.ops_table.link.node;
1271      node.stream_ops = MEMFS.ops_table.link.stream;
1272    } else if (FS.isChrdev(node.mode)) {
1273      node.node_ops = MEMFS.ops_table.chrdev.node;
1274      node.stream_ops = MEMFS.ops_table.chrdev.stream;
1275    }
1276    node.atime = node.mtime = node.ctime = Date.now();
1277    if (parent) {
1278      parent.contents[name] = node;
1279      parent.atime = parent.mtime = parent.ctime = node.atime;
1280    }
1281    return node;
1282  },
1283  getFileDataAsTypedArray(node) {
1284    if (!node.contents) return new Uint8Array(0);
1285    if (node.contents.subarray)
1286      return node.contents.subarray(0, node.usedBytes);
1287    return new Uint8Array(node.contents);
1288  },
1289  expandFileStorage(node, newCapacity) {
1290    var prevCapacity = node.contents ? node.contents.length : 0;
1291    if (prevCapacity >= newCapacity) return;
1292    var CAPACITY_DOUBLING_MAX = 1024 * 1024;
1293    newCapacity = Math.max(
1294      newCapacity,
1295      (prevCapacity * (prevCapacity < CAPACITY_DOUBLING_MAX ? 2 : 1.125)) >>> 0
1296    );
1297    if (prevCapacity != 0) newCapacity = Math.max(newCapacity, 256);
1298    var oldContents = node.contents;
1299    node.contents = new Uint8Array(newCapacity);
1300    if (node.usedBytes > 0)
1301      node.contents.set(oldContents.subarray(0, node.usedBytes), 0);
1302  },
1303  resizeFileStorage(node, newSize) {
1304    if (node.usedBytes == newSize) return;
1305    if (newSize == 0) {
1306      node.contents = null;
1307      node.usedBytes = 0;
1308    } else {
1309      var oldContents = node.contents;
1310      node.contents = new Uint8Array(newSize);
1311      if (oldContents) {
1312        node.contents.set(
1313          oldContents.subarray(0, Math.min(newSize, node.usedBytes))
1314        );
1315      }
1316      node.usedBytes = newSize;
1317    }
1318  },
1319  node_ops: {
1320    getattr(node) {
1321      var attr = {};
1322      attr.dev = FS.isChrdev(node.mode) ? node.id : 1;
1323      attr.ino = node.id;
1324      attr.mode = node.mode;
1325      attr.nlink = 1;
1326      attr.uid = 0;
1327      attr.gid = 0;
1328      attr.rdev = node.rdev;
1329      if (FS.isDir(node.mode)) {
1330        attr.size = 4096;
1331      } else if (FS.isFile(node.mode)) {
1332        attr.size = node.usedBytes;
1333      } else if (FS.isLink(node.mode)) {
1334        attr.size = node.link.length;
1335      } else {
1336        attr.size = 0;
1337      }
1338      attr.atime = new Date(node.atime);
1339      attr.mtime = new Date(node.mtime);
1340      attr.ctime = new Date(node.ctime);
1341      attr.blksize = 4096;
1342      attr.blocks = Math.ceil(attr.size / attr.blksize);
1343      return attr;
1344    },
1345    setattr(node, attr) {
1346      for (const key of ["mode", "atime", "mtime", "ctime"]) {
1347        if (attr[key] != null) {
1348          node[key] = attr[key];
1349        }
1350      }
1351      if (attr.size !== undefined) {
1352        MEMFS.resizeFileStorage(node, attr.size);
1353      }
1354    },
1355    lookup(parent, name) {
1356      throw MEMFS.doesNotExistError;
1357    },
1358    mknod(parent, name, mode, dev) {
1359      return MEMFS.createNode(parent, name, mode, dev);
1360    },
1361    rename(old_node, new_dir, new_name) {
1362      var new_node;
1363      try {
1364        new_node = FS.lookupNode(new_dir, new_name);
1365      } catch (e) {}
1366      if (new_node) {
1367        if (FS.isDir(old_node.mode)) {
1368          for (var i in new_node.contents) {
1369            throw new FS.ErrnoError(55);
1370          }
1371        }
1372        FS.hashRemoveNode(new_node);
1373      }
1374      delete old_node.parent.contents[old_node.name];
1375      new_dir.contents[new_name] = old_node;
1376      old_node.name = new_name;
1377      new_dir.ctime =
1378        new_dir.mtime =
1379        old_node.parent.ctime =
1380        old_node.parent.mtime =
1381          Date.now();
1382    },
1383    unlink(parent, name) {
1384      delete parent.contents[name];
1385      parent.ctime = parent.mtime = Date.now();
1386    },
1387    rmdir(parent, name) {
1388      var node = FS.lookupNode(parent, name);
1389      for (var i in node.contents) {
1390        throw new FS.ErrnoError(55);
1391      }
1392      delete parent.contents[name];
1393      parent.ctime = parent.mtime = Date.now();
1394    },
1395    readdir(node) {
1396      return [".", "..", ...Object.keys(node.contents)];
1397    },
1398    symlink(parent, newname, oldpath) {
1399      var node = MEMFS.createNode(parent, newname, 511 | 40960, 0);
1400      node.link = oldpath;
1401      return node;
1402    },
1403    readlink(node) {
1404      if (!FS.isLink(node.mode)) {
1405        throw new FS.ErrnoError(28);
1406      }
1407      return node.link;
1408    },
1409  },
1410  stream_ops: {
1411    read(stream, buffer, offset, length, position) {
1412      var contents = stream.node.contents;
1413      if (position >= stream.node.usedBytes) return 0;
1414      var size = Math.min(stream.node.usedBytes - position, length);
1415      if (size > 8 && contents.subarray) {
1416        buffer.set(contents.subarray(position, position + size), offset);
1417      } else {
1418        for (var i = 0; i < size; i++)
1419          buffer[offset + i] = contents[position + i];
1420      }
1421      return size;
1422    },
1423    write(stream, buffer, offset, length, position, canOwn) {
1424      if (buffer.buffer === HEAP8.buffer) {
1425        canOwn = false;

1426      }
1427      if (!length) return 0;
1428      var node = stream.node;
1429      node.mtime = node.ctime = Date.now();
1430      if (buffer.subarray && (!node.contents || node.contents.subarray)) {
1431        if (canOwn) {
1432          node.contents = buffer.subarray(offset, offset + length);
1433          node.usedBytes = length;
1434          return length;
1435        } else if (node.usedBytes === 0 && position === 0) {
1436          node.contents = buffer.slice(offset, offset + length);
1437          node.usedBytes = length;
1438          return length;
1439        } else if (position + length <= node.usedBytes) {
1440          node.contents.set(buffer.subarray(offset, offset + length), position);
1441          return length;
1442        }
1443      }
1444      MEMFS.expandFileStorage(node, position + length);
1445      if (node.contents.subarray && buffer.subarray) {
1446        node.contents.set(buffer.subarray(offset, offset + length), position);
1447      } else {
1448        for (var i = 0; i < length; i++) {
1449          node.contents[position + i] = buffer[offset + i];
1450        }
1451      }
1452      node.usedBytes = Math.max(node.usedBytes, position + length);
1453      return length;
1454    },
1455    llseek(stream, offset, whence) {
1456      var position = offset;
1457      if (whence === 1) {
1458        position += stream.position;
1459      } else if (whence === 2) {
1460        if (FS.isFile(stream.node.mode)) {
1461          position += stream.node.usedBytes;
1462        }
1463      }
1464      if (position < 0) {
1465        throw new FS.ErrnoError(28);
1466      }
1467      return position;
1468    },
1469    allocate(stream, offset, length) {
1470      MEMFS.expandFileStorage(stream.node, offset + length);
1471      stream.node.usedBytes = Math.max(stream.node.usedBytes, offset + length);
1472    },
1473    mmap(stream, length, position, prot, flags) {
1474      if (!FS.isFile(stream.node.mode)) {
1475        throw new FS.ErrnoError(43);
1476      }
1477      var ptr;
1478      var allocated;
1479      var contents = stream.node.contents;
1480      if (!(flags & 2) && contents && contents.buffer === HEAP8.buffer) {
1481        allocated = false;
1482        ptr = contents.byteOffset;
1483      } else {
1484        allocated = true;
1485        ptr = mmapAlloc(length);
1486        if (!ptr) {
1487          throw new FS.ErrnoError(48);
1488        }
1489        if (contents) {
1490          if (position > 0 || position + length < contents.length) {
1491            if (contents.subarray) {
1492              contents = contents.subarray(position, position + length);
1493            } else {
1494              contents = Array.prototype.slice.call(
1495                contents,
1496                position,
1497                position + length
1498              );
1499            }
1500          }
1501          HEAP8.set(contents, ptr);
1502        }
1503      }
1504      return { ptr, allocated };
1505    },
1506    msync(stream, buffer, offset, length, mmapFlags) {
1507      MEMFS.stream_ops.write(stream, buffer, 0, length, offset, false);
1508      return 0;
1509    },
1510  },
1511};
1512var asyncLoad = async (url) => {
1513  var arrayBuffer = await readAsync(url);
1514  return new Uint8Array(arrayBuffer);
1515};
1516var FS_createDataFile = (parent, name, fileData, canRead, canWrite, canOwn) => {
1517  FS.createDataFile(parent, name, fileData, canRead, canWrite, canOwn);
1518};
1519var preloadPlugins = Module["preloadPlugins"] || [];
1520var FS_handledByPreloadPlugin = (byteArray, fullname, finish, onerror) => {
1521  if (typeof Browser != "undefined") Browser.init();
1522  var handled = false;
1523  preloadPlugins.forEach((plugin) => {
1524    if (handled) return;
1525    if (plugin["canHandle"](fullname)) {
1526      plugin["handle"](byteArray, fullname, finish, onerror);
1527      handled = true;
1528    }
1529  });
1530  return handled;
1531};
1532var FS_createPreloadedFile = (
1533  parent,
1534  name,
1535  url,
1536  canRead,
1537  canWrite,
1538  onload,
1539  onerror,
1540  dontCreateFile,
1541  canOwn,
1542  preFinish
1543) => {
1544  var fullname = name ? PATH_FS.resolve(PATH.join2(parent, name)) : parent;
1545  var dep = getUniqueRunDependency(`cp ${fullname}`);
1546  function processData(byteArray) {
1547    function finish(byteArray) {
1548      preFinish?.();
1549      if (!dontCreateFile) {
1550        FS_createDataFile(parent, name, byteArray, canRead, canWrite, canOwn);
1551      }
1552      onload?.();
1553      removeRunDependency(dep);
1554    }
1555    if (
1556      FS_handledByPreloadPlugin(byteArray, fullname, finish, () => {
1557        onerror?.();
1558        removeRunDependency(dep);
1559      })
1560    ) {
1561      return;
1562    }
1563    finish(byteArray);
1564  }
1565  addRunDependency(dep);
1566  if (typeof url == "string") {
1567    asyncLoad(url).then(processData, onerror);
1568  } else {
1569    processData(url);
1570  }
1571};
1572var FS_modeStringToFlags = (str) => {
1573  var flagModes = {
1574    r: 0,
1575    "r+": 2,
1576    w: 512 | 64 | 1,
1577    "w+": 512 | 64 | 2,
1578    a: 1024 | 64 | 1,
1579    "a+": 1024 | 64 | 2,
1580  };
1581  var flags = flagModes[str];
1582  if (typeof flags == "undefined") {
1583    throw new Error(`Unknown file open mode: ${str}`);
1584  }
1585  return flags;
1586};
1587var FS_getMode = (canRead, canWrite) => {
1588  var mode = 0;
1589  if (canRead) mode |= 292 | 73;
1590  if (canWrite) mode |= 146;
1591  return mode;
1592};
1593var FS = {
1594  root: null,
1595  mounts: [],
1596  devices: {},
1597  streams: [],
1598  nextInode: 1,
1599  nameTable: null,
1600  currentPath: "/",
1601  initialized: false,
1602  ignorePermissions: true,
1603  ErrnoError: class {
1604    name = "ErrnoError";
1605    constructor(errno) {
1606      this.errno = errno;
1607    }
1608  },
1609  filesystems: null,
1610  syncFSRequests: 0,
1611  readFiles: {},
1612  FSStream: class {
1613    shared = {};
1614    get object() {
1615      return this.node;
1616    }
1617    set object(val) {
1618      this.node = val;
1619    }
1620    get isRead() {
1621      return (this.flags & 2097155) !== 1;
1622    }
1623    get isWrite() {
1624      return (this.flags & 2097155) !== 0;
1625    }
1626    get isAppend() {
1627      return this.flags & 1024;
1628    }
1629    get flags() {
1630      return this.shared.flags;
1631    }
1632    set flags(val) {
1633      this.shared.flags = val;
1634    }
1635    get position() {
1636      return this.shared.position;
1637    }
1638    set position(val) {
1639      this.shared.position = val;
1640    }
1641  },
1642  FSNode: class {
1643    node_ops = {};
1644    stream_ops = {};
1645    readMode = 292 | 73;
1646    writeMode = 146;
1647    mounted = null;
1648    constructor(parent, name, mode, rdev) {
1649      if (!parent) {
1650        parent = this;
1651      }
1652      this.parent = parent;
1653      this.mount = parent.mount;
1654      this.id = FS.nextInode++;
1655      this.name = name;
1656      this.mode = mode;
1657      this.rdev = rdev;
1658      this.atime = this.mtime = this.ctime = Date.now();
1659    }
1660    get read() {
1661      return (this.mode & this.readMode) === this.readMode;
1662    }
1663    set read(val) {
1664      val ? (this.mode |= this.readMode) : (this.mode &= ~this.readMode);
1665    }
1666    get write() {
1667      return (this.mode & this.writeMode) === this.writeMode;
1668    }
1669    set write(val) {
1670      val ? (this.mode |= this.writeMode) : (this.mode &= ~this.writeMode);
1671    }
1672    get isFolder() {
1673      return FS.isDir(this.mode);
1674    }
1675    get isDevice() {
1676      return FS.isChrdev(this.mode);
1677    }
1678  },
1679  lookupPath(path, opts = {}) {
1680    if (!path) {
1681      throw new FS.ErrnoError(44);
1682    }
1683    opts.follow_mount ??= true;
1684    if (!PATH.isAbs(path)) {
1685      path = FS.cwd() + "/" + path;
1686    }
1687    linkloop: for (var nlinks = 0; nlinks < 40; nlinks++) {
1688      var parts = path.split("/").filter((p) => !!p);
1689      var current = FS.root;
1690      var current_path = "/";
1691      for (var i = 0; i < parts.length; i++) {
1692        var islast = i === parts.length - 1;
1693        if (islast && opts.parent) {
1694          break;
1695        }
1696        if (parts[i] === ".") {
1697          continue;
1698        }
1699        if (parts[i] === "..") {
1700          current_path = PATH.dirname(current_path);
1701          current = current.parent;
1702          continue;
1703        }
1704        current_path = PATH.join2(current_path, parts[i]);
1705        try {
1706          current = FS.lookupNode(current, parts[i]);
1707        } catch (e) {
1708          if (e?.errno === 44 && islast && opts.noent_okay) {
1709            return { path: current_path };
1710          }
1711          throw e;
1712        }
1713        if (FS.isMountpoint(current) && (!islast || opts.follow_mount)) {
1714          current = current.mounted.root;
1715        }
1716        if (FS.isLink(current.mode) && (!islast || opts.follow)) {
1717          if (!current.node_ops.readlink) {
1718            throw new FS.ErrnoError(52);
1719          }
1720          var link = current.node_ops.readlink(current);
1721          if (!PATH.isAbs(link)) {
1722            link = PATH.dirname(current_path) + "/" + link;
1723          }
1724          path = link + "/" + parts.slice(i + 1).join("/");
1725          continue linkloop;
1726        }
1727      }
1728      return { path: current_path, node: current };
1729    }
1730    throw new FS.ErrnoError(32);
1731  },
1732  getPath(node) {
1733    var path;
1734    while (true) {
1735      if (FS.isRoot(node)) {
1736        var mount = node.mount.mountpoint;
1737        if (!path) return mount;
1738        return mount[mount.length - 1] !== "/"
1739          ? `${mount}/${path}`
1740          : mount + path;
1741      }
1742      path = path ? `${node.name}/${path}` : node.name;
1743      node = node.parent;
1744    }
1745  },
1746  hashName(parentid, name) {
1747    var hash = 0;
1748    for (var i = 0; i < name.length; i++) {
1749      hash = ((hash << 5) - hash + name.charCodeAt(i)) | 0;
1750    }
1751    return ((parentid + hash) >>> 0) % FS.nameTable.length;
1752  },
1753  hashAddNode(node) {
1754    var hash = FS.hashName(node.parent.id, node.name);
1755    node.name_next = FS.nameTable[hash];
1756    FS.nameTable[hash] = node;
1757  },
1758  hashRemoveNode(node) {
1759    var hash = FS.hashName(node.parent.id, node.name);
1760    if (FS.nameTable[hash] === node) {
1761      FS.nameTable[hash] = node.name_next;
1762    } else {
1763      var current = FS.nameTable[hash];
1764      while (current) {
1765        if (current.name_next === node) {
1766          current.name_next = node.name_next;
1767          break;
1768        }
1769        current = current.name_next;
1770      }
1771    }
1772  },
1773  lookupNode(parent, name) {
1774    var errCode = FS.mayLookup(parent);
1775    if (errCode) {
1776      throw new FS.ErrnoError(errCode);
1777    }
1778    var hash = FS.hashName(parent.id, name);
1779    for (var node = FS.nameTable[hash]; node; node = node.name_next) {
1780      var nodeName = node.name;
1781      if (node.parent.id === parent.id && nodeName === name) {
1782        return node;
1783      }
1784    }
1785    return FS.lookup(parent, name);
1786  },
1787  createNode(parent, name, mode, rdev) {
1788    var node = new FS.FSNode(parent, name, mode, rdev);
1789    FS.hashAddNode(node);
1790    return node;
1791  },
1792  destroyNode(node) {
1793    FS.hashRemoveNode(node);
1794  },
1795  isRoot(node) {
1796    return node === node.parent;
1797  },
1798  isMountpoint(node) {
1799    return !!node.mounted;
1800  },
1801  isFile(mode) {
1802    return (mode & 61440) === 32768;
1803  },
1804  isDir(mode) {
1805    return (mode & 61440) === 16384;
1806  },
1807  isLink(mode) {
1808    return (mode & 61440) === 40960;
1809  },
1810  isChrdev(mode) {
1811    return (mode & 61440) === 8192;
1812  },
1813  isBlkdev(mode) {
1814    return (mode & 61440) === 24576;
1815  },
1816  isFIFO(mode) {
1817    return (mode & 61440) === 4096;
1818  },
1819  isSocket(mode) {
1820    return (mode & 49152) === 49152;
1821  },
1822  flagsToPermissionString(flag) {
1823    var perms = ["r", "w", "rw"][flag & 3];
1824    if (flag & 512) {
1825      perms += "w";
1826    }
1827    return perms;
1828  },
1829  nodePermissions(node, perms) {
1830    if (FS.ignorePermissions) {
1831      return 0;
1832    }
1833    if (perms.includes("r") && !(node.mode & 292)) {
1834      return 2;
1835    } else if (perms.includes("w") && !(node.mode & 146)) {
1836      return 2;
1837    } else if (perms.includes("x") && !(node.mode & 73)) {
1838      return 2;
1839    }
1840    return 0;
1841  },
1842  mayLookup(dir) {
1843    if (!FS.isDir(dir.mode)) return 54;
1844    var errCode = FS.nodePermissions(dir, "x");
1845    if (errCode) return errCode;
1846    if (!dir.node_ops.lookup) return 2;
1847    return 0;
1848  },
1849  mayCreate(dir, name) {
1850    if (!FS.isDir(dir.mode)) {
1851      return 54;
1852    }
1853    try {
1854      var node = FS.lookupNode(dir, name);
1855      return 20;
1856    } catch (e) {}
1857    return FS.nodePermissions(dir, "wx");
1858  },
1859  mayDelete(dir, name, isdir) {
1860    var node;
1861    try {
1862      node = FS.lookupNode(dir, name);
1863    } catch (e) {
1864      return e.errno;
1865    }
1866    var errCode = FS.nodePermissions(dir, "wx");
1867    if (errCode) {
1868      return errCode;
1869    }
1870    if (isdir) {
1871      if (!FS.isDir(node.mode)) {
1872        return 54;
1873      }
1874      if (FS.isRoot(node) || FS.getPath(node) === FS.cwd()) {
1875        return 10;
1876      }
1877    } else {
1878      if (FS.isDir(node.mode)) {
1879        return 31;
1880      }
1881    }
1882    return 0;
1883  },
1884  mayOpen(node, flags) {
1885    if (!node) {
1886      return 44;
1887    }
1888    if (FS.isLink(node.mode)) {
1889      return 32;
1890    } else if (FS.isDir(node.mode)) {
1891      if (FS.flagsToPermissionString(flags) !== "r" || flags & (512 | 64)) {
1892        return 31;
1893      }
1894    }
1895    return FS.nodePermissions(node, FS.flagsToPermissionString(flags));
1896  },
1897  checkOpExists(op, err) {
1898    if (!op) {
1899      throw new FS.ErrnoError(err);
1900    }
1901    return op;
1902  },
1903  MAX_OPEN_FDS: 4096,
1904  nextfd() {
1905    for (var fd = 0; fd <= FS.MAX_OPEN_FDS; fd++) {
1906      if (!FS.streams[fd]) {
1907        return fd;
1908      }
1909    }
1910    throw new FS.ErrnoError(33);
1911  },
1912  getStreamChecked(fd) {
1913    var stream = FS.getStream(fd);
1914    if (!stream) {
1915      throw new FS.ErrnoError(8);
1916    }
1917    return stream;
1918  },
1919  getStream: (fd) => FS.streams[fd],
1920  createStream(stream, fd = -1) {
1921    stream = Object.assign(new FS.FSStream(), stream);
1922    if (fd == -1) {
1923      fd = FS.nextfd();
1924    }
1925    stream.fd = fd;
1926    FS.streams[fd] = stream;
1927    return stream;
1928  },
1929  closeStream(fd) {
1930    FS.streams[fd] = null;
1931  },
1932  dupStream(origStream, fd = -1) {
1933    var stream = FS.createStream(origStream, fd);
1934    stream.stream_ops?.dup?.(stream);
1935    return stream;
1936  },
1937  doSetAttr(stream, node, attr) {
1938    var setattr = stream?.stream_ops.setattr;
1939    var arg = setattr ? stream : node;
1940    setattr ??= node.node_ops.setattr;
1941    FS.checkOpExists(setattr, 63);
1942    setattr(arg, attr);
1943  },
1944  chrdev_stream_ops: {
1945    open(stream) {
1946      var device = FS.getDevice(stream.node.rdev);
1947      stream.stream_ops = device.stream_ops;
1948      stream.stream_ops.open?.(stream);
1949    },
1950    llseek() {
1951      throw new FS.ErrnoError(70);
1952    },
1953  },
1954  major: (dev) => dev >> 8,
1955  minor: (dev) => dev & 255,
1956  makedev: (ma, mi) => (ma << 8) | mi,
1957  registerDevice(dev, ops) {
1958    FS.devices[dev] = { stream_ops: ops };
1959  },
1960  getDevice: (dev) => FS.devices[dev],
1961  getMounts(mount) {
1962    var mounts = [];
1963    var check = [mount];
1964    while (check.length) {
1965      var m = check.pop();
1966      mounts.push(m);
1967      check.push(...m.mounts);
1968    }
1969    return mounts;
1970  },
1971  syncfs(populate, callback) {
1972    if (typeof populate == "function") {
1973      callback = populate;
1974      populate = false;
1975    }
1976    FS.syncFSRequests++;
1977    if (FS.syncFSRequests > 1) {
1978      err(
1979        `warning: ${FS.syncFSRequests} FS.syncfs operations in flight at once, probably just doing extra work`
1980      );
1981    }
1982    var mounts = FS.getMounts(FS.root.mount);
1983    var completed = 0;
1984    function doCallback(errCode) {
1985      FS.syncFSRequests--;
1986      return callback(errCode);
1987    }
1988    function done(errCode) {
1989      if (errCode) {
1990        if (!done.errored) {
1991          done.errored = true;
1992          return doCallback(errCode);
1993        }
1994        return;
1995      }
1996      if (++completed >= mounts.length) {
1997        doCallback(null);
1998      }
1999    }
2000    mounts.forEach((mount) => {
2001      if (!mount.type.syncfs) {
2002        return done(null);
2003      }
2004      mount.type.syncfs(mount, populate, done);
2005    });
2006  },
2007  mount(type, opts, mountpoint) {
2008    var root = mountpoint === "/";
2009    var pseudo = !mountpoint;
2010    var node;
2011    if (root && FS.root) {
2012      throw new FS.ErrnoError(10);
2013    } else if (!root && !pseudo) {
2014      var lookup = FS.lookupPath(mountpoint, { follow_mount: false });
2015      mountpoint = lookup.path;
2016      node = lookup.node;
2017      if (FS.isMountpoint(node)) {
2018        throw new FS.ErrnoError(10);
2019      }
2020      if (!FS.isDir(node.mode)) {
2021        throw new FS.ErrnoError(54);
2022      }
2023    }
2024    var mount = { type, opts, mountpoint, mounts: [] };
2025    var mountRoot = type.mount(mount);
2026    mountRoot.mount = mount;
2027    mount.root = mountRoot;
2028    if (root) {
2029      FS.root = mountRoot;
2030    } else if (node) {
2031      node.mounted = mount;
2032      if (node.mount) {
2033        node.mount.mounts.push(mount);
2034      }
2035    }
2036    return mountRoot;
2037  },
2038  unmount(mountpoint) {
2039    var lookup = FS.lookupPath(mountpoint, { follow_mount: false });
2040    if (!FS.isMountpoint(lookup.node)) {
2041      throw new FS.ErrnoError(28);
2042    }
2043    var node = lookup.node;

2044    var mount = node.mounted;
2045    var mounts = FS.getMounts(mount);
2046    Object.keys(FS.nameTable).forEach((hash) => {
2047      var current = FS.nameTable[hash];
2048      while (current) {
2049        var next = current.name_next;
2050        if (mounts.includes(current.mount)) {
2051          FS.destroyNode(current);
2052        }
2053        current = next;
2054      }
2055    });
2056    node.mounted = null;
2057    var idx = node.mount.mounts.indexOf(mount);
2058    node.mount.mounts.splice(idx, 1);
2059  },
2060  lookup(parent, name) {
2061    return parent.node_ops.lookup(parent, name);
2062  },
2063  mknod(path, mode, dev) {
2064    var lookup = FS.lookupPath(path, { parent: true });
2065    var parent = lookup.node;
2066    var name = PATH.basename(path);
2067    if (!name) {
2068      throw new FS.ErrnoError(28);
2069    }
2070    if (name === "." || name === "..") {
2071      throw new FS.ErrnoError(20);
2072    }
2073    var errCode = FS.mayCreate(parent, name);
2074    if (errCode) {
2075      throw new FS.ErrnoError(errCode);
2076    }
2077    if (!parent.node_ops.mknod) {
2078      throw new FS.ErrnoError(63);
2079    }
2080    return parent.node_ops.mknod(parent, name, mode, dev);
2081  },
2082  statfs(path) {
2083    return FS.statfsNode(FS.lookupPath(path, { follow: true }).node);
2084  },
2085  statfsStream(stream) {
2086    return FS.statfsNode(stream.node);
2087  },
2088  statfsNode(node) {
2089    var rtn = {
2090      bsize: 4096,
2091      frsize: 4096,
2092      blocks: 1e6,
2093      bfree: 5e5,
2094      bavail: 5e5,
2095      files: FS.nextInode,
2096      ffree: FS.nextInode - 1,
2097      fsid: 42,
2098      flags: 2,
2099      namelen: 255,
2100    };
2101    if (node.node_ops.statfs) {
2102      Object.assign(rtn, node.node_ops.statfs(node.mount.opts.root));
2103    }
2104    return rtn;
2105  },
2106  create(path, mode = 438) {
2107    mode &= 4095;
2108    mode |= 32768;
2109    return FS.mknod(path, mode, 0);
2110  },
2111  mkdir(path, mode = 511) {
2112    mode &= 511 | 512;
2113    mode |= 16384;
2114    return FS.mknod(path, mode, 0);
2115  },
2116  mkdirTree(path, mode) {
2117    var dirs = path.split("/");
2118    var d = "";
2119    for (var i = 0; i < dirs.length; ++i) {
2120      if (!dirs[i]) continue;
2121      d += "/" + dirs[i];
2122      try {
2123        FS.mkdir(d, mode);
2124      } catch (e) {
2125        if (e.errno != 20) throw e;
2126      }
2127    }
2128  },
2129  mkdev(path, mode, dev) {
2130    if (typeof dev == "undefined") {
2131      dev = mode;
2132      mode = 438;
2133    }
2134    mode |= 8192;
2135    return FS.mknod(path, mode, dev);
2136  },
2137  symlink(oldpath, newpath) {
2138    if (!PATH_FS.resolve(oldpath)) {
2139      throw new FS.ErrnoError(44);
2140    }
2141    var lookup = FS.lookupPath(newpath, { parent: true });
2142    var parent = lookup.node;
2143    if (!parent) {
2144      throw new FS.ErrnoError(44);
2145    }
2146    var newname = PATH.basename(newpath);
2147    var errCode = FS.mayCreate(parent, newname);
2148    if (errCode) {
2149      throw new FS.ErrnoError(errCode);
2150    }
2151    if (!parent.node_ops.symlink) {
2152      throw new FS.ErrnoError(63);
2153    }
2154    return parent.node_ops.symlink(parent, newname, oldpath);
2155  },
2156  rename(old_path, new_path) {
2157    var old_dirname = PATH.dirname(old_path);
2158    var new_dirname = PATH.dirname(new_path);
2159    var old_name = PATH.basename(old_path);
2160    var new_name = PATH.basename(new_path);
2161    var lookup, old_dir, new_dir;
2162    lookup = FS.lookupPath(old_path, { parent: true });
2163    old_dir = lookup.node;
2164    lookup = FS.lookupPath(new_path, { parent: true });
2165    new_dir = lookup.node;
2166    if (!old_dir || !new_dir) throw new FS.ErrnoError(44);
2167    if (old_dir.mount !== new_dir.mount) {
2168      throw new FS.ErrnoError(75);
2169    }
2170    var old_node = FS.lookupNode(old_dir, old_name);
2171    var relative = PATH_FS.relative(old_path, new_dirname);
2172    if (relative.charAt(0) !== ".") {
2173      throw new FS.ErrnoError(28);
2174    }
2175    relative = PATH_FS.relative(new_path, old_dirname);
2176    if (relative.charAt(0) !== ".") {
2177      throw new FS.ErrnoError(55);
2178    }
2179    var new_node;
2180    try {
2181      new_node = FS.lookupNode(new_dir, new_name);
2182    } catch (e) {}
2183    if (old_node === new_node) {
2184      return;
2185    }
2186    var isdir = FS.isDir(old_node.mode);
2187    var errCode = FS.mayDelete(old_dir, old_name, isdir);
2188    if (errCode) {
2189      throw new FS.ErrnoError(errCode);
2190    }
2191    errCode = new_node
2192      ? FS.mayDelete(new_dir, new_name, isdir)
2193      : FS.mayCreate(new_dir, new_name);
2194    if (errCode) {
2195      throw new FS.ErrnoError(errCode);
2196    }
2197    if (!old_dir.node_ops.rename) {
2198      throw new FS.ErrnoError(63);
2199    }
2200    if (FS.isMountpoint(old_node) || (new_node && FS.isMountpoint(new_node))) {
2201      throw new FS.ErrnoError(10);
2202    }
2203    if (new_dir !== old_dir) {
2204      errCode = FS.nodePermissions(old_dir, "w");
2205      if (errCode) {
2206        throw new FS.ErrnoError(errCode);
2207      }
2208    }
2209    FS.hashRemoveNode(old_node);
2210    try {
2211      old_dir.node_ops.rename(old_node, new_dir, new_name);
2212      old_node.parent = new_dir;
2213    } catch (e) {
2214      throw e;
2215    } finally {
2216      FS.hashAddNode(old_node);
2217    }
2218  },
2219  rmdir(path) {
2220    var lookup = FS.lookupPath(path, { parent: true });
2221    var parent = lookup.node;
2222    var name = PATH.basename(path);
2223    var node = FS.lookupNode(parent, name);
2224    var errCode = FS.mayDelete(parent, name, true);
2225    if (errCode) {
2226      throw new FS.ErrnoError(errCode);
2227    }
2228    if (!parent.node_ops.rmdir) {
2229      throw new FS.ErrnoError(63);
2230    }
2231    if (FS.isMountpoint(node)) {
2232      throw new FS.ErrnoError(10);
2233    }
2234    parent.node_ops.rmdir(parent, name);
2235    FS.destroyNode(node);
2236  },
2237  readdir(path) {
2238    var lookup = FS.lookupPath(path, { follow: true });
2239    var node = lookup.node;
2240    var readdir = FS.checkOpExists(node.node_ops.readdir, 54);
2241    return readdir(node);
2242  },
2243  unlink(path) {
2244    var lookup = FS.lookupPath(path, { parent: true });
2245    var parent = lookup.node;
2246    if (!parent) {
2247      throw new FS.ErrnoError(44);
2248    }
2249    var name = PATH.basename(path);
2250    var node = FS.lookupNode(parent, name);
2251    var errCode = FS.mayDelete(parent, name, false);
2252    if (errCode) {
2253      throw new FS.ErrnoError(errCode);
2254    }
2255    if (!parent.node_ops.unlink) {
2256      throw new FS.ErrnoError(63);
2257    }
2258    if (FS.isMountpoint(node)) {
2259      throw new FS.ErrnoError(10);
2260    }
2261    parent.node_ops.unlink(parent, name);
2262    FS.destroyNode(node);
2263  },
2264  readlink(path) {
2265    var lookup = FS.lookupPath(path);
2266    var link = lookup.node;
2267    if (!link) {
2268      throw new FS.ErrnoError(44);
2269    }
2270    if (!link.node_ops.readlink) {
2271      throw new FS.ErrnoError(28);
2272    }
2273    return link.node_ops.readlink(link);
2274  },
2275  stat(path, dontFollow) {
2276    var lookup = FS.lookupPath(path, { follow: !dontFollow });
2277    var node = lookup.node;
2278    var getattr = FS.checkOpExists(node.node_ops.getattr, 63);
2279    return getattr(node);
2280  },
2281  fstat(fd) {

2282    var stream = FS.getStreamChecked(fd);
2283    var node = stream.node;
2284    var getattr = stream.stream_ops.getattr;
2285    var arg = getattr ? stream : node;
2286    getattr ??= node.node_ops.getattr;
2287    FS.checkOpExists(getattr, 63);
2288    return getattr(arg);
2289  },
2290  lstat(path) {
2291    return FS.stat(path, true);
2292  },
2293  doChmod(stream, node, mode, dontFollow) {
2294    FS.doSetAttr(stream, node, {
2295      mode: (mode & 4095) | (node.mode & ~4095),
2296      ctime: Date.now(),
2297      dontFollow,
2298    });
2299  },
2300  chmod(path, mode, dontFollow) {
2301    var node;
2302    if (typeof path == "string") {
2303      var lookup = FS.lookupPath(path, { follow: !dontFollow });
2304      node = lookup.node;
2305    } else {
2306      node = path;
2307    }
2308    FS.doChmod(null, node, mode, dontFollow);
2309  },
2310  lchmod(path, mode) {
2311    FS.chmod(path, mode, true);
2312  },
2313  fchmod(fd, mode) {
2314    var stream = FS.getStreamChecked(fd);
2315    FS.doChmod(stream, stream.node, mode, false);
2316  },
2317  doChown(stream, node, dontFollow) {
2318    FS.doSetAttr(stream, node, { timestamp: Date.now(), dontFollow });
2319  },
2320  chown(path, uid, gid, dontFollow) {
2321    var node;
2322    if (typeof path == "string") {
2323      var lookup = FS.lookupPath(path, { follow: !dontFollow });
2324      node = lookup.node;
2325    } else {
2326      node = path;
2327    }
2328    FS.doChown(null, node, dontFollow);
2329  },
2330  lchown(path, uid, gid) {
2331    FS.chown(path, uid, gid, true);
2332  },
2333  fchown(fd, uid, gid) {
2334    var stream = FS.getStreamChecked(fd);
2335    FS.doChown(stream, stream.node, false);
2336  },
2337  doTruncate(stream, node, len) {
2338    if (FS.isDir(node.mode)) {
2339      throw new FS.ErrnoError(31);
2340    }
2341    if (!FS.isFile(node.mode)) {
2342      throw new FS.ErrnoError(28);
2343    }
2344    var errCode = FS.nodePermissions(node, "w");
2345    if (errCode) {
2346      throw new FS.ErrnoError(errCode);
2347    }
2348    FS.doSetAttr(stream, node, { size: len, timestamp: Date.now() });
2349  },
2350  truncate(path, len) {
2351    if (len < 0) {
2352      throw new FS.ErrnoError(28);
2353    }
2354    var node;
2355    if (typeof path == "string") {
2356      var lookup = FS.lookupPath(path, { follow: true });
2357      node = lookup.node;
2358    } else {
2359      node = path;
2360    }
2361    FS.doTruncate(null, node, len);
2362  },
2363  ftruncate(fd, len) {
2364    var stream = FS.getStreamChecked(fd);
2365    if (len < 0 || (stream.flags & 2097155) === 0) {
2366      throw new FS.ErrnoError(28);
2367    }
2368    FS.doTruncate(stream, stream.node, len);
2369  },
2370  utime(path, atime, mtime) {
2371    var lookup = FS.lookupPath(path, { follow: true });
2372    var node = lookup.node;
2373    var setattr = FS.checkOpExists(node.node_ops.setattr, 63);
2374    setattr(node, { atime, mtime });
2375  },
2376  open(path, flags, mode = 438) {
2377    if (path === "") {
2378      throw new FS.ErrnoError(44);
2379    }
2380    flags = typeof flags == "string" ? FS_modeStringToFlags(flags) : flags;
2381    if (flags & 64) {
2382      mode = (mode & 4095) | 32768;
2383    } else {
2384      mode = 0;
2385    }
2386    var node;
2387    var isDirPath;
2388    if (typeof path == "object") {
2389      node = path;
2390    } else {
2391      isDirPath = path.endsWith("/");
2392      var lookup = FS.lookupPath(path, {
2393        follow: !(flags & 131072),
2394        noent_okay: true,
2395      });
2396      node = lookup.node;
2397      path = lookup.path;
2398    }
2399    var created = false;
2400    if (flags & 64) {
2401      if (node) {
2402        if (flags & 128) {
2403          throw new FS.ErrnoError(20);
2404        }
2405      } else if (isDirPath) {
2406        throw new FS.ErrnoError(31);
2407      } else {
2408        node = FS.mknod(path, mode | 511, 0);
2409        created = true;
2410      }
2411    }
2412    if (!node) {
2413      throw new FS.ErrnoError(44);
2414    }
2415    if (FS.isChrdev(node.mode)) {
2416      flags &= ~512;
2417    }
2418    if (flags & 65536 && !FS.isDir(node.mode)) {
2419      throw new FS.ErrnoError(54);
2420    }
2421    if (!created) {
2422      var errCode = FS.mayOpen(node, flags);
2423      if (errCode) {
2424        throw new FS.ErrnoError(errCode);
2425      }
2426    }
2427    if (flags & 512 && !created) {
2428      FS.truncate(node, 0);
2429    }
2430    flags &= ~(128 | 512 | 131072);
2431    var stream = FS.createStream({
2432      node,
2433      path: FS.getPath(node),
2434      flags,
2435      seekable: true,
2436      position: 0,
2437      stream_ops: node.stream_ops,
2438      ungotten: [],
2439      error: false,
2440    });
2441    if (stream.stream_ops.open) {
2442      stream.stream_ops.open(stream);
2443    }
2444    if (created) {
2445      FS.chmod(node, mode & 511);
2446    }
2447    if (Module["logReadFiles"] && !(flags & 1)) {
2448      if (!(path in FS.readFiles)) {
2449        FS.readFiles[path] = 1;
2450      }
2451    }
2452    return stream;
2453  },
2454  close(stream) {
2455    if (FS.isClosed(stream)) {
2456      throw new FS.ErrnoError(8);
2457    }
2458    if (stream.getdents) stream.getdents = null;
2459    try {
2460      if (stream.stream_ops.close) {
2461        stream.stream_ops.close(stream);
2462      }
2463    } catch (e) {
2464      throw e;
2465    } finally {
2466      FS.closeStream(stream.fd);
2467    }
2468    stream.fd = null;
2469  },
2470  isClosed(stream) {
2471    return stream.fd === null;
2472  },
2473  llseek(stream, offset, whence) {
2474    if (FS.isClosed(stream)) {
2475      throw new FS.ErrnoError(8);
2476    }
2477    if (!stream.seekable || !stream.stream_ops.llseek) {
2478      throw new FS.ErrnoError(70);
2479    }
2480    if (whence != 0 && whence != 1 && whence != 2) {
2481      throw new FS.ErrnoError(28);
2482    }
2483    stream.position = stream.stream_ops.llseek(stream, offset, whence);
2484    stream.ungotten = [];
2485    return stream.position;
2486  },
2487  read(stream, buffer, offset, length, position) {
2488    if (length < 0 || position < 0) {
2489      throw new FS.ErrnoError(28);
2490    }
2491    if (FS.isClosed(stream)) {
2492      throw new FS.ErrnoError(8);
2493    }
2494    if ((stream.flags & 2097155) === 1) {
2495      throw new FS.ErrnoError(8);
2496    }
2497    if (FS.isDir(stream.node.mode)) {
2498      throw new FS.ErrnoError(31);
2499    }
2500    if (!stream.stream_ops.read) {
2501      throw new FS.ErrnoError(28);
2502    }
2503    var seeking = typeof position != "undefined";
2504    if (!seeking) {
2505      position = stream.position;
2506    } else if (!stream.seekable) {
2507      throw new FS.ErrnoError(70);
2508    }
2509    var bytesRead = stream.stream_ops.read(
2510      stream,
2511      buffer,
2512      offset,
2513      length,
2514      position
2515    );
2516    if (!seeking) stream.position += bytesRead;
2517    return bytesRead;
2518  },
2519  write(stream, buffer, offset, length, position, canOwn) {
2520    if (length < 0 || position < 0) {
2521      throw new FS.ErrnoError(28);
2522    }
2523    if (FS.isClosed(stream)) {
2524      throw new FS.ErrnoError(8);
2525    }
2526    if ((stream.flags & 2097155) === 0) {
2527      throw new FS.ErrnoError(8);
2528    }
2529    if (FS.isDir(stream.node.mode)) {
2530      throw new FS.ErrnoError(31);
2531    }
2532    if (!stream.stream_ops.write) {
2533      throw new FS.ErrnoError(28);
2534    }
2535    if (stream.seekable && stream.flags & 1024) {
2536      FS.llseek(stream, 0, 2);
2537    }
2538    var seeking = typeof position != "undefined";
2539    if (!seeking) {
2540      position = stream.position;
2541    } else if (!stream.seekable) {
2542      throw new FS.ErrnoError(70);
2543    }
2544    var bytesWritten = stream.stream_ops.write(
2545      stream,
2546      buffer,
2547      offset,
2548      length,
2549      position,
2550      canOwn
2551    );
2552    if (!seeking) stream.position += bytesWritten;
2553    return bytesWritten;
2554  },
2555  allocate(stream, offset, length) {
2556    if (FS.isClosed(stream)) {
2557      throw new FS.ErrnoError(8);
2558    }
2559    if (offset < 0 || length <= 0) {
2560      throw new FS.ErrnoError(28);
2561    }
2562    if ((stream.flags & 2097155) === 0) {
2563      throw new FS.ErrnoError(8);
2564    }
2565    if (!FS.isFile(stream.node.mode) && !FS.isDir(stream.node.mode)) {
2566      throw new FS.ErrnoError(43);
2567    }
2568    if (!stream.stream_ops.allocate) {
2569      throw new FS.ErrnoError(138);
2570    }
2571    stream.stream_ops.allocate(stream, offset, length);
2572  },
2573  mmap(stream, length, position, prot, flags) {
2574    if (
2575      (prot & 2) !== 0 &&
2576      (flags & 2) === 0 &&
2577      (stream.flags & 2097155) !== 2
2578    ) {
2579      throw new FS.ErrnoError(2);
2580    }
2581    if ((stream.flags & 2097155) === 1) {
2582      throw new FS.ErrnoError(2);
2583    }
2584    if (!stream.stream_ops.mmap) {
2585      throw new FS.ErrnoError(43);
2586    }
2587    if (!length) {
2588      throw new FS.ErrnoError(28);
2589    }
2590    return stream.stream_ops.mmap(stream, length, position, prot, flags);
2591  },
2592  msync(stream, buffer, offset, length, mmapFlags) {
2593    if (!stream.stream_ops.msync) {
2594      return 0;
2595    }
2596    return stream.stream_ops.msync(stream, buffer, offset, length, mmapFlags);
2597  },
2598  ioctl(stream, cmd, arg) {
2599    if (!stream.stream_ops.ioctl) {
2600      throw new FS.ErrnoError(59);
2601    }
2602    return stream.stream_ops.ioctl(stream, cmd, arg);
2603  },
2604  readFile(path, opts = {}) {
2605    opts.flags = opts.flags || 0;
2606    opts.encoding = opts.encoding || "binary";
2607    if (opts.encoding !== "utf8" && opts.encoding !== "binary") {
2608      throw new Error(`Invalid encoding type "${opts.encoding}"`);
2609    }
2610    var ret;
2611    var stream = FS.open(path, opts.flags);
2612    var stat = FS.stat(path);
2613    var length = stat.size;
2614    var buf = new Uint8Array(length);
2615    FS.read(stream, buf, 0, length, 0);
2616    if (opts.encoding === "utf8") {
2617      ret = UTF8ArrayToString(buf);
2618    } else if (opts.encoding === "binary") {
2619      ret = buf;
2620    }
2621    FS.close(stream);
2622    return ret;
2623  },
2624  writeFile(path, data, opts = {}) {
2625    opts.flags = opts.flags || 577;
2626    var stream = FS.open(path, opts.flags, opts.mode);
2627    if (typeof data == "string") {
2628      var buf = new Uint8Array(lengthBytesUTF8(data) + 1);
2629      var actualNumBytes = stringToUTF8Array(data, buf, 0, buf.length);
2630      FS.write(stream, buf, 0, actualNumBytes, undefined, opts.canOwn);
2631    } else if (ArrayBuffer.isView(data)) {
2632      FS.write(stream, data, 0, data.byteLength, undefined, opts.canOwn);
2633    } else {
2634      throw new Error("Unsupported data type");
2635    }
2636    FS.close(stream);
2637  },
2638  cwd: () => FS.currentPath,
2639  chdir(path) {
2640    var lookup = FS.lookupPath(path, { follow: true });
2641    if (lookup.node === null) {
2642      throw new FS.ErrnoError(44);
2643    }
2644    if (!FS.isDir(lookup.node.mode)) {
2645      throw new FS.ErrnoError(54);
2646    }
2647    var errCode = FS.nodePermissions(lookup.node, "x");
2648    if (errCode) {
2649      throw new FS.ErrnoError(errCode);
2650    }
2651    FS.currentPath = lookup.path;
2652  },
2653  createDefaultDirectories() {
2654    FS.mkdir("/tmp");
2655    FS.mkdir("/home");
2656    FS.mkdir("/home/web_user");
2657  },
2658  createDefaultDevices() {
2659    FS.mkdir("/dev");
2660    FS.registerDevice(FS.makedev(1, 3), {
2661      read: () => 0,
2662      write: (stream, buffer, offset, length, pos) => length,
2663      llseek: () => 0,
2664    });
2665    FS.mkdev("/dev/null", FS.makedev(1, 3));
2666    TTY.register(FS.makedev(5, 0), TTY.default_tty_ops);
2667    TTY.register(FS.makedev(6, 0), TTY.default_tty1_ops);
2668    FS.mkdev("/dev/tty", FS.makedev(5, 0));
2669    FS.mkdev("/dev/tty1", FS.makedev(6, 0));
2670    var randomBuffer = new Uint8Array(1024),
2671      randomLeft = 0;
2672    var randomByte = () => {
2673      if (randomLeft === 0) {
2674        randomFill(randomBuffer);
2675        randomLeft = randomBuffer.byteLength;
2676      }
2677      return randomBuffer[--randomLeft];
2678    };
2679    FS.createDevice("/dev", "random", randomByte);
2680    FS.createDevice("/dev", "urandom", randomByte);
2681    FS.mkdir("/dev/shm");
2682    FS.mkdir("/dev/shm/tmp");
2683  },
2684  createSpecialDirectories() {
2685    FS.mkdir("/proc");
2686    var proc_self = FS.mkdir("/proc/self");
2687    FS.mkdir("/proc/self/fd");
2688    FS.mount(
2689      {
2690        mount() {
2691          var node = FS.createNode(proc_self, "fd", 16895, 73);
2692          node.stream_ops = { llseek: MEMFS.stream_ops.llseek };
2693          node.node_ops = {
2694            lookup(parent, name) {
2695              var fd = +name;
2696              var stream = FS.getStreamChecked(fd);
2697              var ret = {
2698                parent: null,
2699                mount: { mountpoint: "fake" },
2700                node_ops: { readlink: () => stream.path },
2701                id: fd + 1,
2702              };
2703              ret.parent = ret;
2704              return ret;
2705            },
2706            readdir() {
2707              return Array.from(FS.streams.entries())
2708                .filter(([k, v]) => v)
2709                .map(([k, v]) => k.toString());
2710            },
2711          };
2712          return node;
2713        },
2714      },
2715      {},
2716      "/proc/self/fd"
2717    );
2718  },
2719  createStandardStreams(input, output, error) {
2720    if (input) {
2721      FS.createDevice("/dev", "stdin", input);
2722    } else {
2723      FS.symlink("/dev/tty", "/dev/stdin");
2724    }
2725    if (output) {
2726      FS.createDevice("/dev", "stdout", null, output);
2727    } else {
2728      FS.symlink("/dev/tty", "/dev/stdout");
2729    }
2730    if (error) {
2731      FS.createDevice("/dev", "stderr", null, error);
2732    } else {
2733      FS.symlink("/dev/tty1", "/dev/stderr");
2734    }
2735    var stdin = FS.open("/dev/stdin", 0);
2736    var stdout = FS.open("/dev/stdout", 1);
2737    var stderr = FS.open("/dev/stderr", 1);
2738  },
2739  staticInit() {
2740    FS.nameTable = new Array(4096);
2741    FS.mount(MEMFS, {}, "/");
2742    FS.createDefaultDirectories();
2743    FS.createDefaultDevices();
2744    FS.createSpecialDirectories();
2745    FS.filesystems = { MEMFS };
2746  },
2747  init(input, output, error) {
2748    FS.initialized = true;
2749    input ??= Module["stdin"];
2750    output ??= Module["stdout"];
2751    error ??= Module["stderr"];
2752    FS.createStandardStreams(input, output, error);
2753  },
2754  quit() {
2755    FS.initialized = false;
2756    for (var i = 0; i < FS.streams.length; i++) {
2757      var stream = FS.streams[i];
2758      if (!stream) {
2759        continue;
2760      }
2761      FS.close(stream);
2762    }
2763  },
2764  findObject(path, dontResolveLastLink) {
2765    var ret = FS.analyzePath(path, dontResolveLastLink);
2766    if (!ret.exists) {
2767      return null;
2768    }
2769    return ret.object;
2770  },
2771  analyzePath(path, dontResolveLastLink) {
2772    try {
2773      var lookup = FS.lookupPath(path, { follow: !dontResolveLastLink });
2774      path = lookup.path;
2775    } catch (e) {}
2776    var ret = {
2777      isRoot: false,
2778      exists: false,
2779      error: 0,
2780      name: null,
2781      path: null,
2782      object: null,
2783      parentExists: false,
2784      parentPath: null,
2785      parentObject: null,
2786    };
2787    try {
2788      var lookup = FS.lookupPath(path, { parent: true });
2789      ret.parentExists = true;
2790      ret.parentPath = lookup.path;
2791      ret.parentObject = lookup.node;
2792      ret.name = PATH.basename(path);
2793      lookup = FS.lookupPath(path, { follow: !dontResolveLastLink });
2794      ret.exists = true;
2795      ret.path = lookup.path;
2796      ret.object = lookup.node;
2797      ret.name = lookup.node.name;
2798      ret.isRoot = lookup.path === "/";
2799    } catch (e) {
2800      ret.error = e.errno;
2801    }
2802    return ret;
2803  },
2804  createPath(parent, path, canRead, canWrite) {
2805    parent = typeof parent == "string" ? parent : FS.getPath(parent);
2806    var parts = path.split("/").reverse();
2807    while (parts.length) {
2808      var part = parts.pop();
2809      if (!part) continue;
2810      var current = PATH.join2(parent, part);
2811      try {
2812        FS.mkdir(current);
2813      } catch (e) {}
2814      parent = current;
2815    }
2816    return current;
2817  },
2818  createFile(parent, name, properties, canRead, canWrite) {
2819    var path = PATH.join2(
2820      typeof parent == "string" ? parent : FS.getPath(parent),
2821      name
2822    );
2823    var mode = FS_getMode(canRead, canWrite);
2824    return FS.create(path, mode);
2825  },
2826  createDataFile(parent, name, data, canRead, canWrite, canOwn) {
2827    var path = name;
2828    if (parent) {
2829      parent = typeof parent == "string" ? parent : FS.getPath(parent);
2830      path = name ? PATH.join2(parent, name) : parent;
2831    }
2832    var mode = FS_getMode(canRead, canWrite);
2833    var node = FS.create(path, mode);
2834    if (data) {
2835      if (typeof data == "string") {
2836        var arr = new Array(data.length);
2837        for (var i = 0, len = data.length; i < len; ++i)
2838          arr[i] = data.charCodeAt(i);
2839        data = arr;
2840      }
2841      FS.chmod(node, mode | 146);
2842      var stream = FS.open(node, 577);
2843      FS.write(stream, data, 0, data.length, 0, canOwn);
2844      FS.close(stream);
2845      FS.chmod(node, mode);
2846    }
2847  },
2848  createDevice(parent, name, input, output) {
2849    var path = PATH.join2(
2850      typeof parent == "string" ? parent : FS.getPath(parent),
2851      name
2852    );
2853    var mode = FS_getMode(!!input, !!output);
2854    FS.createDevice.major ??= 64;
2855    var dev = FS.makedev(FS.createDevice.major++, 0);
2856    FS.registerDevice(dev, {
2857      open(stream) {
2858        stream.seekable = false;
2859      },
2860      close(stream) {
2861        if (output?.buffer?.length) {
2862          output(10);
2863        }
2864      },
2865      read(stream, buffer, offset, length, pos) {
2866        var bytesRead = 0;
2867        for (var i = 0; i < length; i++) {
2868          var result;
2869          try {
2870            result = input();
2871          } catch (e) {
2872            throw new FS.ErrnoError(29);
2873          }
2874          if (result === undefined && bytesRead === 0) {
2875            throw new FS.ErrnoError(6);
2876          }
2877          if (result === null || result === undefined) break;
2878          bytesRead++;
2879          buffer[offset + i] = result;
2880        }
2881        if (bytesRead) {
2882          stream.node.atime = Date.now();
2883        }
2884        return bytesRead;
2885      },
2886      write(stream, buffer, offset, length, pos) {
2887        for (var i = 0; i < length; i++) {
2888          try {
2889            output(buffer[offset + i]);
2890          } catch (e) {
2891            throw new FS.ErrnoError(29);
2892          }
2893        }
2894        if (length) {
2895          stream.node.mtime = stream.node.ctime = Date.now();
2896        }
2897        return i;
2898      },
2899    });
2900    return FS.mkdev(path, mode, dev);
2901  },
2902  forceLoadFile(obj) {
2903    if (obj.isDevice || obj.isFolder || obj.link || obj.contents) return true;
2904    if (typeof XMLHttpRequest != "undefined") {
2905      throw new Error(
2906        "Lazy loading should have been performed (contents set) in createLazyFile, but it was not. Lazy loading only works in web workers. Use --embed-file or --preload-file in emcc on the main thread."
2907      );
2908    } else {
2909      try {
2910        obj.contents = readBinary(obj.url);
2911        obj.usedBytes = obj.contents.length;
2912      } catch (e) {
2913        throw new FS.ErrnoError(29);
2914      }
2915    }
2916  },
2917  createLazyFile(parent, name, url, canRead, canWrite) {
2918    class LazyUint8Array {
2919      lengthKnown = false;
2920      chunks = [];
2921      get(idx) {
2922        if (idx > this.length - 1 || idx < 0) {
2923          return undefined;
2924        }
2925        var chunkOffset = idx % this.chunkSize;
2926        var chunkNum = (idx / this.chunkSize) | 0;
2927        return this.getter(chunkNum)[chunkOffset];
2928      }
2929      setDataGetter(getter) {
2930        this.getter = getter;
2931      }
2932      cacheLength() {
2933        var xhr = new XMLHttpRequest();
2934        xhr.open("HEAD", url, false);
2935        xhr.send(null);
2936        if (!((xhr.status >= 200 && xhr.status < 300) || xhr.status === 304))
2937          throw new Error("Couldn't load " + url + ". Status: " + xhr.status);
2938        var datalength = Number(xhr.getResponseHeader("Content-length"));
2939        var header;
2940        var hasByteServing =
2941          (header = xhr.getResponseHeader("Accept-Ranges")) &&
2942          header === "bytes";
2943        var usesGzip =
2944          (header = xhr.getResponseHeader("Content-Encoding")) &&
2945          header === "gzip";
2946        var chunkSize = 1024 * 1024;
2947        if (!hasByteServing) chunkSize = datalength;
2948        var doXHR = (from, to) => {
2949          if (from > to)
2950            throw new Error(
2951              "invalid range (" + from + ", " + to + ") or no bytes requested!"
2952            );
2953          if (to > datalength - 1)
2954            throw new Error(
2955              "only " + datalength + " bytes available! programmer error!"
2956            );
2957          var xhr = new XMLHttpRequest();
2958          xhr.open("GET", url, false);
2959          if (datalength !== chunkSize)
2960            xhr.setRequestHeader("Range", "bytes=" + from + "-" + to);
2961          xhr.responseType = "arraybuffer";
2962          if (xhr.overrideMimeType) {
2963            xhr.overrideMimeType("text/plain; charset=x-user-defined");
2964          }
2965          xhr.send(null);
2966          if (!((xhr.status >= 200 && xhr.status < 300) || xhr.status === 304))
2967            throw new Error("Couldn't load " + url + ". Status: " + xhr.status);
2968          if (xhr.response !== undefined) {
2969            return new Uint8Array(xhr.response || []);
2970          }
2971          return intArrayFromString(xhr.responseText || "", true);
2972        };
2973        var lazyArray = this;
2974        lazyArray.setDataGetter((chunkNum) => {
2975          var start = chunkNum * chunkSize;
2976          var end = (chunkNum + 1) * chunkSize - 1;
2977          end = Math.min(end, datalength - 1);
2978          if (typeof lazyArray.chunks[chunkNum] == "undefined") {
2979            lazyArray.chunks[chunkNum] = doXHR(start, end);
2980          }
2981          if (typeof lazyArray.chunks[chunkNum] == "undefined")
2982            throw new Error("doXHR failed!");
2983          return lazyArray.chunks[chunkNum];
2984        });
2985        if (usesGzip || !datalength) {
2986          chunkSize = datalength = 1;
2987          datalength = this.getter(0).length;
2988          chunkSize = datalength;
2989          out(
2990            "LazyFiles on gzip forces download of the whole file when length is accessed"
2991          );
2992        }
2993        this._length = datalength;
2994        this._chunkSize = chunkSize;
2995        this.lengthKnown = true;
2996      }
2997      get length() {
2998        if (!this.lengthKnown) {
2999          this.cacheLength();
3000        }
3001        return this._length;
3002      }
3003      get chunkSize() {
3004        if (!this.lengthKnown) {
3005          this.cacheLength();
3006        }
3007        return this._chunkSize;
3008      }
3009    }
3010    if (typeof XMLHttpRequest != "undefined") {
3011      if (!ENVIRONMENT_IS_WORKER)
3012        throw "Cannot do synchronous binary XHRs outside webworkers in modern browsers. Use --embed-file or --preload-file in emcc";
3013      var lazyArray = new LazyUint8Array();
3014      var properties = { isDevice: false, contents: lazyArray };
3015    } else {
3016      var properties = { isDevice: false, url };
3017    }
3018    var node = FS.createFile(parent, name, properties, canRead, canWrite);
3019    if (properties.contents) {
3020      node.contents = properties.contents;
3021    } else if (properties.url) {
3022      node.contents = null;
3023      node.url = properties.url;
3024    }
3025    Object.defineProperties(node, {
3026      usedBytes: {
3027        get: function () {
3028          return this.contents.length;
3029        },
3030      },
3031    });
3032    var stream_ops = {};
3033    var keys = Object.keys(node.stream_ops);
3034    keys.forEach((key) => {
3035      var fn = node.stream_ops[key];
3036      stream_ops[key] = (...args) => {
3037        FS.forceLoadFile(node);
3038        return fn(...args);
3039      };
3040    });
3041    function writeChunks(stream, buffer, offset, length, position) {
3042      var contents = stream.node.contents;
3043      if (position >= contents.length) return 0;
3044      var size = Math.min(contents.length - position, length);
3045      if (contents.slice) {
3046        for (var i = 0; i < size; i++) {
3047          buffer[offset + i] = contents[position + i];
3048        }
3049      } else {
3050        for (var i = 0; i < size; i++) {
3051          buffer[offset + i] = contents.get(position + i);
3052        }
3053      }
3054      return size;
3055    }
3056    stream_ops.read = (stream, buffer, offset, length, position) => {
3057      FS.forceLoadFile(node);
3058      return writeChunks(stream, buffer, offset, length, position);
3059    };
3060    stream_ops.mmap = (stream, length, position, prot, flags) => {
3061      FS.forceLoadFile(node);
3062      var ptr = mmapAlloc(length);
3063      if (!ptr) {
3064        throw new FS.ErrnoError(48);
3065      }
3066      writeChunks(stream, HEAP8, ptr, length, position);
3067      return { ptr, allocated: true };
3068    };
3069    node.stream_ops = stream_ops;
3070    return node;
3071  },
3072};
3073var SYSCALLS = {
3074  DEFAULT_POLLMASK: 5,
3075  calculateAt(dirfd, path, allowEmpty) {
3076    if (PATH.isAbs(path)) {
3077      return path;
3078    }
3079    var dir;
3080    if (dirfd === -100) {
3081      dir = FS.cwd();
3082    } else {
3083      var dirstream = SYSCALLS.getStreamFromFD(dirfd);
3084      dir = dirstream.path;
3085    }
3086    if (path.length == 0) {
3087      if (!allowEmpty) {
3088        throw new FS.ErrnoError(44);
3089      }
3090      return dir;
3091    }
3092    return dir + "/" + path;
3093  },
3094  writeStat(buf, stat) {
3095    HEAP32[buf >> 2] = stat.dev;
3096    HEAP32[(buf + 4) >> 2] = stat.mode;
3097    HEAPU32[(buf + 8) >> 2] = stat.nlink;
3098    HEAP32[(buf + 12) >> 2] = stat.uid;
3099    HEAP32[(buf + 16) >> 2] = stat.gid;
3100    HEAP32[(buf + 20) >> 2] = stat.rdev;
3101    HEAP64[(buf + 24) >> 3] = BigInt(stat.size);
3102    HEAP32[(buf + 32) >> 2] = 4096;
3103    HEAP32[(buf + 36) >> 2] = stat.blocks;
3104    var atime = stat.atime.getTime();
3105    var mtime = stat.mtime.getTime();
3106    var ctime = stat.ctime.getTime();
3107    HEAP64[(buf + 40) >> 3] = BigInt(Math.floor(atime / 1e3));
3108    HEAPU32[(buf + 48) >> 2] = (atime % 1e3) * 1e3 * 1e3;
3109    HEAP64[(buf + 56) >> 3] = BigInt(Math.floor(mtime / 1e3));
3110    HEAPU32[(buf + 64) >> 2] = (mtime % 1e3) * 1e3 * 1e3;
3111    HEAP64[(buf + 72) >> 3] = BigInt(Math.floor(ctime / 1e3));
3112    HEAPU32[(buf + 80) >> 2] = (ctime % 1e3) * 1e3 * 1e3;
3113    HEAP64[(buf + 88) >> 3] = BigInt(stat.ino);
3114    return 0;
3115  },
3116  writeStatFs(buf, stats) {
3117    HEAP32[(buf + 4) >> 2] = stats.bsize;
3118    HEAP32[(buf + 40) >> 2] = stats.bsize;
3119    HEAP32[(buf + 8) >> 2] = stats.blocks;
3120    HEAP32[(buf + 12) >> 2] = stats.bfree;
3121    HEAP32[(buf + 16) >> 2] = stats.bavail;
3122    HEAP32[(buf + 20) >> 2] = stats.files;
3123    HEAP32[(buf + 24) >> 2] = stats.ffree;
3124    HEAP32[(buf + 28) >> 2] = stats.fsid;
3125    HEAP32[(buf + 44) >> 2] = stats.flags;
3126    HEAP32[(buf + 36) >> 2] = stats.namelen;
3127  },
3128  doMsync(addr, stream, len, flags, offset) {
3129    if (!FS.isFile(stream.node.mode)) {
3130      throw new FS.ErrnoError(43);
3131    }
3132    if (flags & 2) {
3133      return 0;
3134    }
3135    var buffer = HEAPU8.slice(addr, addr + len);
3136    FS.msync(stream, buffer, offset, len, flags);
3137  },
3138  getStreamFromFD(fd) {
3139    var stream = FS.getStreamChecked(fd);
3140    return stream;
3141  },
3142  varargs: undefined,
3143  getStr(ptr) {
3144    var ret = UTF8ToString(ptr);
3145    return ret;
3146  },
3147};
3148function ___syscall_chdir(path) {
3149  try {