trealla-multibundle
Version:
Trealla Prolog bindings for JS
1,500 lines (1,494 loc) • 4.57 MB
JavaScript
var __defProp = Object.defineProperty;
var __name = (target, value) => __defProp(target, "name", { value, configurable: true });
var __export = (target, all) => {
for (var name in all)
__defProp(target, name, { get: all[name], enumerable: true });
};
var __toBinary = /* @__PURE__ */ (() => {
var table = new Uint8Array(128);
for (var i = 0; i < 64; i++) table[i < 26 ? i + 65 : i < 52 ? i + 71 : i < 62 ? i - 4 : i * 4 - 205] = i;
return (base64) => {
var n = base64.length, bytes = new Uint8Array((n - (base64[n - 1] == "=") - (base64[n - 2] == "=")) * 3 / 4 | 0);
for (var i2 = 0, j = 0; i2 < n; ) {
var c0 = table[base64.charCodeAt(i2++)], c1 = table[base64.charCodeAt(i2++)];
var c2 = table[base64.charCodeAt(i2++)], c3 = table[base64.charCodeAt(i2++)];
bytes[j++] = c0 << 2 | c1 >> 4;
bytes[j++] = c1 << 4 | c2 >> 2;
bytes[j++] = c2 << 6 | c3;
}
return bytes;
};
})();
// node_modules/browser_wasi_shim_gaiden/dist/wasi_defs.js
var wasi_defs_exports = {};
__export(wasi_defs_exports, {
ADVICE_DONTNEED: () => ADVICE_DONTNEED,
ADVICE_NOREUSE: () => ADVICE_NOREUSE,
ADVICE_NORMAL: () => ADVICE_NORMAL,
ADVICE_RANDOM: () => ADVICE_RANDOM,
ADVICE_SEQUENTIAL: () => ADVICE_SEQUENTIAL,
ADVICE_WILLNEED: () => ADVICE_WILLNEED,
CLOCKID_MONOTONIC: () => CLOCKID_MONOTONIC,
CLOCKID_PROCESS_CPUTIME_ID: () => CLOCKID_PROCESS_CPUTIME_ID,
CLOCKID_REALTIME: () => CLOCKID_REALTIME,
CLOCKID_THREAD_CPUTIME_ID: () => CLOCKID_THREAD_CPUTIME_ID,
Ciovec: () => Ciovec,
Dirent: () => Dirent,
ERRNO_2BIG: () => ERRNO_2BIG,
ERRNO_ACCES: () => ERRNO_ACCES,
ERRNO_ADDRINUSE: () => ERRNO_ADDRINUSE,
ERRNO_ADDRNOTAVAIL: () => ERRNO_ADDRNOTAVAIL,
ERRNO_AFNOSUPPORT: () => ERRNO_AFNOSUPPORT,
ERRNO_AGAIN: () => ERRNO_AGAIN,
ERRNO_ALREADY: () => ERRNO_ALREADY,
ERRNO_BADF: () => ERRNO_BADF,
ERRNO_BADMSG: () => ERRNO_BADMSG,
ERRNO_BUSY: () => ERRNO_BUSY,
ERRNO_CANCELED: () => ERRNO_CANCELED,
ERRNO_CHILD: () => ERRNO_CHILD,
ERRNO_CONNABORTED: () => ERRNO_CONNABORTED,
ERRNO_CONNREFUSED: () => ERRNO_CONNREFUSED,
ERRNO_CONNRESET: () => ERRNO_CONNRESET,
ERRNO_DEADLK: () => ERRNO_DEADLK,
ERRNO_DESTADDRREQ: () => ERRNO_DESTADDRREQ,
ERRNO_DOM: () => ERRNO_DOM,
ERRNO_DQUOT: () => ERRNO_DQUOT,
ERRNO_EXIST: () => ERRNO_EXIST,
ERRNO_FAULT: () => ERRNO_FAULT,
ERRNO_FBIG: () => ERRNO_FBIG,
ERRNO_HOSTUNREACH: () => ERRNO_HOSTUNREACH,
ERRNO_IDRM: () => ERRNO_IDRM,
ERRNO_ILSEQ: () => ERRNO_ILSEQ,
ERRNO_INPROGRESS: () => ERRNO_INPROGRESS,
ERRNO_INTR: () => ERRNO_INTR,
ERRNO_INVAL: () => ERRNO_INVAL,
ERRNO_IO: () => ERRNO_IO,
ERRNO_ISCONN: () => ERRNO_ISCONN,
ERRNO_ISDIR: () => ERRNO_ISDIR,
ERRNO_LOOP: () => ERRNO_LOOP,
ERRNO_MFILE: () => ERRNO_MFILE,
ERRNO_MLINK: () => ERRNO_MLINK,
ERRNO_MSGSIZE: () => ERRNO_MSGSIZE,
ERRNO_MULTIHOP: () => ERRNO_MULTIHOP,
ERRNO_NAMETOOLONG: () => ERRNO_NAMETOOLONG,
ERRNO_NETDOWN: () => ERRNO_NETDOWN,
ERRNO_NETRESET: () => ERRNO_NETRESET,
ERRNO_NETUNREACH: () => ERRNO_NETUNREACH,
ERRNO_NFILE: () => ERRNO_NFILE,
ERRNO_NOBUFS: () => ERRNO_NOBUFS,
ERRNO_NODEV: () => ERRNO_NODEV,
ERRNO_NOENT: () => ERRNO_NOENT,
ERRNO_NOEXEC: () => ERRNO_NOEXEC,
ERRNO_NOLCK: () => ERRNO_NOLCK,
ERRNO_NOLINK: () => ERRNO_NOLINK,
ERRNO_NOMEM: () => ERRNO_NOMEM,
ERRNO_NOMSG: () => ERRNO_NOMSG,
ERRNO_NOPROTOOPT: () => ERRNO_NOPROTOOPT,
ERRNO_NOSPC: () => ERRNO_NOSPC,
ERRNO_NOSYS: () => ERRNO_NOSYS,
ERRNO_NOTCAPABLE: () => ERRNO_NOTCAPABLE,
ERRNO_NOTCONN: () => ERRNO_NOTCONN,
ERRNO_NOTDIR: () => ERRNO_NOTDIR,
ERRNO_NOTEMPTY: () => ERRNO_NOTEMPTY,
ERRNO_NOTRECOVERABLE: () => ERRNO_NOTRECOVERABLE,
ERRNO_NOTSOCK: () => ERRNO_NOTSOCK,
ERRNO_NOTSUP: () => ERRNO_NOTSUP,
ERRNO_NOTTY: () => ERRNO_NOTTY,
ERRNO_NXIO: () => ERRNO_NXIO,
ERRNO_OVERFLOW: () => ERRNO_OVERFLOW,
ERRNO_OWNERDEAD: () => ERRNO_OWNERDEAD,
ERRNO_PERM: () => ERRNO_PERM,
ERRNO_PIPE: () => ERRNO_PIPE,
ERRNO_PROTO: () => ERRNO_PROTO,
ERRNO_PROTONOSUPPORT: () => ERRNO_PROTONOSUPPORT,
ERRNO_PROTOTYPE: () => ERRNO_PROTOTYPE,
ERRNO_RANGE: () => ERRNO_RANGE,
ERRNO_ROFS: () => ERRNO_ROFS,
ERRNO_SPIPE: () => ERRNO_SPIPE,
ERRNO_SRCH: () => ERRNO_SRCH,
ERRNO_STALE: () => ERRNO_STALE,
ERRNO_SUCCESS: () => ERRNO_SUCCESS,
ERRNO_TIMEDOUT: () => ERRNO_TIMEDOUT,
ERRNO_TXTBSY: () => ERRNO_TXTBSY,
ERRNO_XDEV: () => ERRNO_XDEV,
EVENTRWFLAGS_FD_READWRITE_HANGUP: () => EVENTRWFLAGS_FD_READWRITE_HANGUP,
EVENTTYPE_CLOCK: () => EVENTTYPE_CLOCK,
EVENTTYPE_FD_READ: () => EVENTTYPE_FD_READ,
EVENTTYPE_FD_WRITE: () => EVENTTYPE_FD_WRITE,
FDFLAGS_APPEND: () => FDFLAGS_APPEND,
FDFLAGS_DSYNC: () => FDFLAGS_DSYNC,
FDFLAGS_NONBLOCK: () => FDFLAGS_NONBLOCK,
FDFLAGS_RSYNC: () => FDFLAGS_RSYNC,
FDFLAGS_SYNC: () => FDFLAGS_SYNC,
FD_STDERR: () => FD_STDERR,
FD_STDIN: () => FD_STDIN,
FD_STDOUT: () => FD_STDOUT,
FILETYPE_BLOCK_DEVICE: () => FILETYPE_BLOCK_DEVICE,
FILETYPE_CHARACTER_DEVICE: () => FILETYPE_CHARACTER_DEVICE,
FILETYPE_DIRECTORY: () => FILETYPE_DIRECTORY,
FILETYPE_REGULAR_FILE: () => FILETYPE_REGULAR_FILE,
FILETYPE_SOCKET_DGRAM: () => FILETYPE_SOCKET_DGRAM,
FILETYPE_SOCKET_STREAM: () => FILETYPE_SOCKET_STREAM,
FILETYPE_SYMBOLIC_LINK: () => FILETYPE_SYMBOLIC_LINK,
FILETYPE_UNKNOWN: () => FILETYPE_UNKNOWN,
FSTFLAGS_ATIM: () => FSTFLAGS_ATIM,
FSTFLAGS_ATIM_NOW: () => FSTFLAGS_ATIM_NOW,
FSTFLAGS_MTIM: () => FSTFLAGS_MTIM,
FSTFLAGS_MTIM_NOW: () => FSTFLAGS_MTIM_NOW,
Fdstat: () => Fdstat,
Filestat: () => Filestat,
Iovec: () => Iovec,
OFLAGS_CREAT: () => OFLAGS_CREAT,
OFLAGS_DIRECTORY: () => OFLAGS_DIRECTORY,
OFLAGS_EXCL: () => OFLAGS_EXCL,
OFLAGS_TRUNC: () => OFLAGS_TRUNC,
PREOPENTYPE_DIR: () => PREOPENTYPE_DIR,
Prestat: () => Prestat,
PrestatDir: () => PrestatDir,
RIFLAGS_RECV_PEEK: () => RIFLAGS_RECV_PEEK,
RIFLAGS_RECV_WAITALL: () => RIFLAGS_RECV_WAITALL,
RIGHTS_FD_ADVISE: () => RIGHTS_FD_ADVISE,
RIGHTS_FD_ALLOCATE: () => RIGHTS_FD_ALLOCATE,
RIGHTS_FD_DATASYNC: () => RIGHTS_FD_DATASYNC,
RIGHTS_FD_FDSTAT_SET_FLAGS: () => RIGHTS_FD_FDSTAT_SET_FLAGS,
RIGHTS_FD_FILESTAT_GET: () => RIGHTS_FD_FILESTAT_GET,
RIGHTS_FD_FILESTAT_SET_SIZE: () => RIGHTS_FD_FILESTAT_SET_SIZE,
RIGHTS_FD_FILESTAT_SET_TIMES: () => RIGHTS_FD_FILESTAT_SET_TIMES,
RIGHTS_FD_READ: () => RIGHTS_FD_READ,
RIGHTS_FD_READDIR: () => RIGHTS_FD_READDIR,
RIGHTS_FD_SEEK: () => RIGHTS_FD_SEEK,
RIGHTS_FD_SYNC: () => RIGHTS_FD_SYNC,
RIGHTS_FD_TELL: () => RIGHTS_FD_TELL,
RIGHTS_FD_WRITE: () => RIGHTS_FD_WRITE,
RIGHTS_PATH_CREATE_DIRECTORY: () => RIGHTS_PATH_CREATE_DIRECTORY,
RIGHTS_PATH_CREATE_FILE: () => RIGHTS_PATH_CREATE_FILE,
RIGHTS_PATH_FILESTAT_GET: () => RIGHTS_PATH_FILESTAT_GET,
RIGHTS_PATH_FILESTAT_SET_SIZE: () => RIGHTS_PATH_FILESTAT_SET_SIZE,
RIGHTS_PATH_FILESTAT_SET_TIMES: () => RIGHTS_PATH_FILESTAT_SET_TIMES,
RIGHTS_PATH_LINK_SOURCE: () => RIGHTS_PATH_LINK_SOURCE,
RIGHTS_PATH_LINK_TARGET: () => RIGHTS_PATH_LINK_TARGET,
RIGHTS_PATH_OPEN: () => RIGHTS_PATH_OPEN,
RIGHTS_PATH_READLINK: () => RIGHTS_PATH_READLINK,
RIGHTS_PATH_REMOVE_DIRECTORY: () => RIGHTS_PATH_REMOVE_DIRECTORY,
RIGHTS_PATH_RENAME_SOURCE: () => RIGHTS_PATH_RENAME_SOURCE,
RIGHTS_PATH_RENAME_TARGET: () => RIGHTS_PATH_RENAME_TARGET,
RIGHTS_PATH_SYMLINK: () => RIGHTS_PATH_SYMLINK,
RIGHTS_PATH_UNLINK_FILE: () => RIGHTS_PATH_UNLINK_FILE,
RIGHTS_POLL_FD_READWRITE: () => RIGHTS_POLL_FD_READWRITE,
RIGHTS_SOCK_SHUTDOWN: () => RIGHTS_SOCK_SHUTDOWN,
ROFLAGS_RECV_DATA_TRUNCATED: () => ROFLAGS_RECV_DATA_TRUNCATED,
SDFLAGS_RD: () => SDFLAGS_RD,
SDFLAGS_WR: () => SDFLAGS_WR,
SIGNAL_ABRT: () => SIGNAL_ABRT,
SIGNAL_ALRM: () => SIGNAL_ALRM,
SIGNAL_BUS: () => SIGNAL_BUS,
SIGNAL_CHLD: () => SIGNAL_CHLD,
SIGNAL_CONT: () => SIGNAL_CONT,
SIGNAL_FPE: () => SIGNAL_FPE,
SIGNAL_HUP: () => SIGNAL_HUP,
SIGNAL_ILL: () => SIGNAL_ILL,
SIGNAL_INT: () => SIGNAL_INT,
SIGNAL_KILL: () => SIGNAL_KILL,
SIGNAL_NONE: () => SIGNAL_NONE,
SIGNAL_PIPE: () => SIGNAL_PIPE,
SIGNAL_POLL: () => SIGNAL_POLL,
SIGNAL_PROF: () => SIGNAL_PROF,
SIGNAL_PWR: () => SIGNAL_PWR,
SIGNAL_QUIT: () => SIGNAL_QUIT,
SIGNAL_SEGV: () => SIGNAL_SEGV,
SIGNAL_STOP: () => SIGNAL_STOP,
SIGNAL_SYS: () => SIGNAL_SYS,
SIGNAL_TERM: () => SIGNAL_TERM,
SIGNAL_TRAP: () => SIGNAL_TRAP,
SIGNAL_TSTP: () => SIGNAL_TSTP,
SIGNAL_TTIN: () => SIGNAL_TTIN,
SIGNAL_TTOU: () => SIGNAL_TTOU,
SIGNAL_URG: () => SIGNAL_URG,
SIGNAL_USR1: () => SIGNAL_USR1,
SIGNAL_USR2: () => SIGNAL_USR2,
SIGNAL_VTALRM: () => SIGNAL_VTALRM,
SIGNAL_WINCH: () => SIGNAL_WINCH,
SIGNAL_XCPU: () => SIGNAL_XCPU,
SIGNAL_XFSZ: () => SIGNAL_XFSZ,
SUBCLOCKFLAGS_SUBSCRIPTION_CLOCK_ABSTIME: () => SUBCLOCKFLAGS_SUBSCRIPTION_CLOCK_ABSTIME,
WHENCE_CUR: () => WHENCE_CUR,
WHENCE_END: () => WHENCE_END,
WHENCE_SET: () => WHENCE_SET
});
var FD_STDIN = 0;
var FD_STDOUT = 1;
var FD_STDERR = 2;
var CLOCKID_REALTIME = 0;
var CLOCKID_MONOTONIC = 1;
var CLOCKID_PROCESS_CPUTIME_ID = 2;
var CLOCKID_THREAD_CPUTIME_ID = 3;
var ERRNO_SUCCESS = 0;
var ERRNO_2BIG = 1;
var ERRNO_ACCES = 2;
var ERRNO_ADDRINUSE = 3;
var ERRNO_ADDRNOTAVAIL = 4;
var ERRNO_AFNOSUPPORT = 5;
var ERRNO_AGAIN = 6;
var ERRNO_ALREADY = 7;
var ERRNO_BADF = 8;
var ERRNO_BADMSG = 9;
var ERRNO_BUSY = 10;
var ERRNO_CANCELED = 11;
var ERRNO_CHILD = 12;
var ERRNO_CONNABORTED = 13;
var ERRNO_CONNREFUSED = 14;
var ERRNO_CONNRESET = 15;
var ERRNO_DEADLK = 16;
var ERRNO_DESTADDRREQ = 17;
var ERRNO_DOM = 18;
var ERRNO_DQUOT = 19;
var ERRNO_EXIST = 20;
var ERRNO_FAULT = 21;
var ERRNO_FBIG = 22;
var ERRNO_HOSTUNREACH = 23;
var ERRNO_IDRM = 24;
var ERRNO_ILSEQ = 25;
var ERRNO_INPROGRESS = 26;
var ERRNO_INTR = 27;
var ERRNO_INVAL = 28;
var ERRNO_IO = 29;
var ERRNO_ISCONN = 30;
var ERRNO_ISDIR = 31;
var ERRNO_LOOP = 32;
var ERRNO_MFILE = 33;
var ERRNO_MLINK = 34;
var ERRNO_MSGSIZE = 35;
var ERRNO_MULTIHOP = 36;
var ERRNO_NAMETOOLONG = 37;
var ERRNO_NETDOWN = 38;
var ERRNO_NETRESET = 39;
var ERRNO_NETUNREACH = 40;
var ERRNO_NFILE = 41;
var ERRNO_NOBUFS = 42;
var ERRNO_NODEV = 43;
var ERRNO_NOENT = 44;
var ERRNO_NOEXEC = 45;
var ERRNO_NOLCK = 46;
var ERRNO_NOLINK = 47;
var ERRNO_NOMEM = 48;
var ERRNO_NOMSG = 49;
var ERRNO_NOPROTOOPT = 50;
var ERRNO_NOSPC = 51;
var ERRNO_NOSYS = 52;
var ERRNO_NOTCONN = 53;
var ERRNO_NOTDIR = 54;
var ERRNO_NOTEMPTY = 55;
var ERRNO_NOTRECOVERABLE = 56;
var ERRNO_NOTSOCK = 57;
var ERRNO_NOTSUP = 58;
var ERRNO_NOTTY = 59;
var ERRNO_NXIO = 60;
var ERRNO_OVERFLOW = 61;
var ERRNO_OWNERDEAD = 62;
var ERRNO_PERM = 63;
var ERRNO_PIPE = 64;
var ERRNO_PROTO = 65;
var ERRNO_PROTONOSUPPORT = 66;
var ERRNO_PROTOTYPE = 67;
var ERRNO_RANGE = 68;
var ERRNO_ROFS = 69;
var ERRNO_SPIPE = 70;
var ERRNO_SRCH = 71;
var ERRNO_STALE = 72;
var ERRNO_TIMEDOUT = 73;
var ERRNO_TXTBSY = 74;
var ERRNO_XDEV = 75;
var ERRNO_NOTCAPABLE = 76;
var RIGHTS_FD_DATASYNC = 1 << 0;
var RIGHTS_FD_READ = 1 << 1;
var RIGHTS_FD_SEEK = 1 << 2;
var RIGHTS_FD_FDSTAT_SET_FLAGS = 1 << 3;
var RIGHTS_FD_SYNC = 1 << 4;
var RIGHTS_FD_TELL = 1 << 5;
var RIGHTS_FD_WRITE = 1 << 6;
var RIGHTS_FD_ADVISE = 1 << 7;
var RIGHTS_FD_ALLOCATE = 1 << 8;
var RIGHTS_PATH_CREATE_DIRECTORY = 1 << 9;
var RIGHTS_PATH_CREATE_FILE = 1 << 10;
var RIGHTS_PATH_LINK_SOURCE = 1 << 11;
var RIGHTS_PATH_LINK_TARGET = 1 << 12;
var RIGHTS_PATH_OPEN = 1 << 13;
var RIGHTS_FD_READDIR = 1 << 14;
var RIGHTS_PATH_READLINK = 1 << 15;
var RIGHTS_PATH_RENAME_SOURCE = 1 << 16;
var RIGHTS_PATH_RENAME_TARGET = 1 << 17;
var RIGHTS_PATH_FILESTAT_GET = 1 << 18;
var RIGHTS_PATH_FILESTAT_SET_SIZE = 1 << 19;
var RIGHTS_PATH_FILESTAT_SET_TIMES = 1 << 20;
var RIGHTS_FD_FILESTAT_GET = 1 << 21;
var RIGHTS_FD_FILESTAT_SET_SIZE = 1 << 22;
var RIGHTS_FD_FILESTAT_SET_TIMES = 1 << 23;
var RIGHTS_PATH_SYMLINK = 1 << 24;
var RIGHTS_PATH_REMOVE_DIRECTORY = 1 << 25;
var RIGHTS_PATH_UNLINK_FILE = 1 << 26;
var RIGHTS_POLL_FD_READWRITE = 1 << 27;
var RIGHTS_SOCK_SHUTDOWN = 1 << 28;
var Iovec = class _Iovec {
static {
__name(this, "Iovec");
}
//@ts-ignore strictPropertyInitialization
buf;
//@ts-ignore strictPropertyInitialization
buf_len;
static read_bytes(view, ptr) {
const iovec = new _Iovec();
iovec.buf = view.getUint32(ptr, true);
iovec.buf_len = view.getUint32(ptr + 4, true);
return iovec;
}
static read_bytes_array(view, ptr, len) {
const iovecs = [];
for (let i = 0; i < len; i++) {
iovecs.push(_Iovec.read_bytes(view, ptr + 8 * i));
}
return iovecs;
}
};
var Ciovec = class _Ciovec {
static {
__name(this, "Ciovec");
}
//@ts-ignore strictPropertyInitialization
buf;
//@ts-ignore strictPropertyInitialization
buf_len;
static read_bytes(view, ptr) {
const iovec = new _Ciovec();
iovec.buf = view.getUint32(ptr, true);
iovec.buf_len = view.getUint32(ptr + 4, true);
return iovec;
}
static read_bytes_array(view, ptr, len) {
const iovecs = [];
for (let i = 0; i < len; i++) {
iovecs.push(_Ciovec.read_bytes(view, ptr + 8 * i));
}
return iovecs;
}
};
var WHENCE_SET = 0;
var WHENCE_CUR = 1;
var WHENCE_END = 2;
var FILETYPE_UNKNOWN = 0;
var FILETYPE_BLOCK_DEVICE = 1;
var FILETYPE_CHARACTER_DEVICE = 2;
var FILETYPE_DIRECTORY = 3;
var FILETYPE_REGULAR_FILE = 4;
var FILETYPE_SOCKET_DGRAM = 5;
var FILETYPE_SOCKET_STREAM = 6;
var FILETYPE_SYMBOLIC_LINK = 7;
var Dirent = class {
static {
__name(this, "Dirent");
}
d_next;
d_ino = 0n;
d_namlen;
d_type;
dir_name;
constructor(next_cookie, name, type) {
const encoded_name = new TextEncoder().encode(name);
this.d_next = next_cookie;
this.d_namlen = encoded_name.byteLength;
this.d_type = type;
this.dir_name = encoded_name;
}
head_length() {
return 24;
}
name_length() {
return this.dir_name.byteLength;
}
write_head_bytes(view, ptr) {
view.setBigUint64(ptr, this.d_next, true);
view.setBigUint64(ptr + 8, this.d_ino, true);
view.setUint32(ptr + 16, this.dir_name.length, true);
view.setUint8(ptr + 20, this.d_type);
}
write_name_bytes(view8, ptr, buf_len) {
view8.set(this.dir_name.slice(0, Math.min(this.dir_name.byteLength, buf_len)), ptr);
}
};
var ADVICE_NORMAL = 0;
var ADVICE_SEQUENTIAL = 1;
var ADVICE_RANDOM = 2;
var ADVICE_WILLNEED = 3;
var ADVICE_DONTNEED = 4;
var ADVICE_NOREUSE = 5;
var FDFLAGS_APPEND = 1 << 0;
var FDFLAGS_DSYNC = 1 << 1;
var FDFLAGS_NONBLOCK = 1 << 2;
var FDFLAGS_RSYNC = 1 << 3;
var FDFLAGS_SYNC = 1 << 4;
var Fdstat = class {
static {
__name(this, "Fdstat");
}
fs_filetype;
fs_flags;
fs_rights_base = 0n;
fs_rights_inherited = 0n;
constructor(filetype, flags) {
this.fs_filetype = filetype;
this.fs_flags = flags;
}
write_bytes(view, ptr) {
view.setUint8(ptr, this.fs_filetype);
view.setUint16(ptr + 2, this.fs_flags, true);
view.setBigUint64(ptr + 8, this.fs_rights_base, true);
view.setBigUint64(ptr + 16, this.fs_rights_inherited, true);
}
};
var FSTFLAGS_ATIM = 1 << 0;
var FSTFLAGS_ATIM_NOW = 1 << 1;
var FSTFLAGS_MTIM = 1 << 2;
var FSTFLAGS_MTIM_NOW = 1 << 3;
var OFLAGS_CREAT = 1 << 0;
var OFLAGS_DIRECTORY = 1 << 1;
var OFLAGS_EXCL = 1 << 2;
var OFLAGS_TRUNC = 1 << 3;
var Filestat = class {
static {
__name(this, "Filestat");
}
dev = 0n;
ino = 0n;
filetype;
nlink = 0n;
size;
atim = 0n;
mtim = 0n;
ctim = 0n;
constructor(filetype, size) {
this.filetype = filetype;
this.size = size;
}
write_bytes(view, ptr) {
view.setBigUint64(ptr, this.dev, true);
view.setBigUint64(ptr + 8, this.ino, true);
view.setUint8(ptr + 16, this.filetype);
view.setBigUint64(ptr + 24, this.nlink, true);
view.setBigUint64(ptr + 32, this.size, true);
view.setBigUint64(ptr + 38, this.atim, true);
view.setBigUint64(ptr + 46, this.mtim, true);
view.setBigUint64(ptr + 52, this.ctim, true);
}
};
var EVENTTYPE_CLOCK = 0;
var EVENTTYPE_FD_READ = 1;
var EVENTTYPE_FD_WRITE = 2;
var EVENTRWFLAGS_FD_READWRITE_HANGUP = 1 << 0;
var SUBCLOCKFLAGS_SUBSCRIPTION_CLOCK_ABSTIME = 1 << 0;
var SIGNAL_NONE = 0;
var SIGNAL_HUP = 1;
var SIGNAL_INT = 2;
var SIGNAL_QUIT = 3;
var SIGNAL_ILL = 4;
var SIGNAL_TRAP = 5;
var SIGNAL_ABRT = 6;
var SIGNAL_BUS = 7;
var SIGNAL_FPE = 8;
var SIGNAL_KILL = 9;
var SIGNAL_USR1 = 10;
var SIGNAL_SEGV = 11;
var SIGNAL_USR2 = 12;
var SIGNAL_PIPE = 13;
var SIGNAL_ALRM = 14;
var SIGNAL_TERM = 15;
var SIGNAL_CHLD = 16;
var SIGNAL_CONT = 17;
var SIGNAL_STOP = 18;
var SIGNAL_TSTP = 19;
var SIGNAL_TTIN = 20;
var SIGNAL_TTOU = 21;
var SIGNAL_URG = 22;
var SIGNAL_XCPU = 23;
var SIGNAL_XFSZ = 24;
var SIGNAL_VTALRM = 25;
var SIGNAL_PROF = 26;
var SIGNAL_WINCH = 27;
var SIGNAL_POLL = 28;
var SIGNAL_PWR = 29;
var SIGNAL_SYS = 30;
var RIFLAGS_RECV_PEEK = 1 << 0;
var RIFLAGS_RECV_WAITALL = 1 << 1;
var ROFLAGS_RECV_DATA_TRUNCATED = 1 << 0;
var SDFLAGS_RD = 1 << 0;
var SDFLAGS_WR = 1 << 1;
var PREOPENTYPE_DIR = 0;
var PrestatDir = class {
static {
__name(this, "PrestatDir");
}
pr_name;
constructor(name) {
this.pr_name = new TextEncoder().encode(name);
}
write_bytes(view, ptr) {
view.setUint32(ptr, this.pr_name.byteLength, true);
}
};
var Prestat = class _Prestat {
static {
__name(this, "Prestat");
}
//@ts-ignore strictPropertyInitialization
tag;
//@ts-ignore strictPropertyInitialization
inner;
static dir(name) {
const prestat = new _Prestat();
prestat.tag = PREOPENTYPE_DIR;
prestat.inner = new PrestatDir(name);
return prestat;
}
write_bytes(view, ptr) {
view.setUint32(ptr, this.tag, true);
this.inner.write_bytes(view, ptr + 4);
}
};
// node_modules/browser_wasi_shim_gaiden/dist/debug.js
var Debug = class {
static {
__name(this, "Debug");
}
isEnabled;
prefix = "wasi:";
log;
constructor(isEnabled) {
this.isEnabled = isEnabled;
this.enable(isEnabled);
}
// Recreate the logger function with the new enabled state.
enable(enabled) {
this.log = createLogger(enabled === void 0 ? true : enabled, this.prefix);
}
// Getter for the private isEnabled property.
get enabled() {
return this.isEnabled;
}
};
function createLogger(enabled, prefix) {
if (enabled) {
const a = console.log.bind(console, "%c%s", "color: #265BA0", prefix);
return a;
} else {
return () => {
};
}
}
__name(createLogger, "createLogger");
var debug = new Debug(false);
// node_modules/browser_wasi_shim_gaiden/dist/wasi.js
var WASIProcExit = class extends Error {
static {
__name(this, "WASIProcExit");
}
code;
constructor(code) {
super("exit with exit code " + code);
this.code = code;
}
};
var WASI = class {
static {
__name(this, "WASI");
}
args = [];
env = [];
fds = [];
inst;
// eslint-disable-next-line @typescript-eslint/no-explicit-any
wasiImport;
/// Start a WASI command
start(instance) {
this.inst = instance;
try {
instance.exports._start();
return 0;
} catch (e) {
if (e instanceof WASIProcExit) {
return e.code;
} else {
throw e;
}
}
}
/// Initialize a WASI reactor
initialize(instance) {
this.inst = instance;
if (instance.exports._initialize) {
instance.exports._initialize();
}
}
constructor(args, env, fds, options = {}) {
debug.enable(options.debug);
this.args = args;
this.env = env;
this.fds = fds;
const self = this;
this.wasiImport = {
args_sizes_get(argc, argv_buf_size) {
const buffer = new DataView(self.inst.exports.memory.buffer);
buffer.setUint32(argc, self.args.length, true);
let buf_size = 0;
for (const arg of self.args) {
buf_size += arg.length + 1;
}
buffer.setUint32(argv_buf_size, buf_size, true);
debug.log(buffer.getUint32(argc, true), buffer.getUint32(argv_buf_size, true));
return 0;
},
args_get(argv, argv_buf) {
const buffer = new DataView(self.inst.exports.memory.buffer);
const buffer8 = new Uint8Array(self.inst.exports.memory.buffer);
const orig_argv_buf = argv_buf;
for (let i = 0; i < self.args.length; i++) {
buffer.setUint32(argv, argv_buf, true);
argv += 4;
const arg = new TextEncoder().encode(self.args[i]);
buffer8.set(arg, argv_buf);
buffer.setUint8(argv_buf + arg.length, 0);
argv_buf += arg.length + 1;
}
if (debug.enabled) {
debug.log(new TextDecoder("utf-8").decode(buffer8.slice(orig_argv_buf, argv_buf)));
}
return 0;
},
environ_sizes_get(environ_count, environ_size) {
const buffer = new DataView(self.inst.exports.memory.buffer);
buffer.setUint32(environ_count, self.env.length, true);
let buf_size = 0;
for (const environ of self.env) {
buf_size += environ.length + 1;
}
buffer.setUint32(environ_size, buf_size, true);
debug.log(buffer.getUint32(environ_count, true), buffer.getUint32(environ_size, true));
return 0;
},
environ_get(environ, environ_buf) {
const buffer = new DataView(self.inst.exports.memory.buffer);
const buffer8 = new Uint8Array(self.inst.exports.memory.buffer);
const orig_environ_buf = environ_buf;
for (let i = 0; i < self.env.length; i++) {
buffer.setUint32(environ, environ_buf, true);
environ += 4;
const e = new TextEncoder().encode(self.env[i]);
buffer8.set(e, environ_buf);
buffer.setUint8(environ_buf + e.length, 0);
environ_buf += e.length + 1;
}
if (debug.enabled) {
debug.log(new TextDecoder("utf-8").decode(buffer8.slice(orig_environ_buf, environ_buf)));
}
return 0;
},
// eslint-disable-next-line @typescript-eslint/no-unused-vars
clock_res_get(id, res_ptr) {
let resolutionValue;
switch (id) {
case CLOCKID_MONOTONIC: {
resolutionValue = 5000n;
break;
}
case CLOCKID_REALTIME: {
resolutionValue = 1000000n;
break;
}
default:
return ERRNO_NOSYS;
}
const view = new DataView(self.inst.exports.memory.buffer);
view.setBigUint64(res_ptr, resolutionValue, true);
return ERRNO_SUCCESS;
},
clock_time_get(id, precision, time) {
const buffer = new DataView(self.inst.exports.memory.buffer);
if (id === CLOCKID_REALTIME) {
buffer.setBigUint64(time, BigInt((/* @__PURE__ */ new Date()).getTime()) * 1000000n, true);
} else if (id == CLOCKID_MONOTONIC) {
let monotonic_time;
try {
monotonic_time = BigInt(Math.round(performance.now() * 1e6));
} catch (e) {
monotonic_time = 0n;
}
buffer.setBigUint64(time, monotonic_time, true);
} else {
buffer.setBigUint64(time, 0n, true);
}
return 0;
},
fd_advise(fd, offset, len, advice) {
if (self.fds[fd] != void 0) {
return ERRNO_SUCCESS;
} else {
return ERRNO_BADF;
}
},
fd_allocate(fd, offset, len) {
if (self.fds[fd] != void 0) {
return self.fds[fd].fd_allocate(offset, len);
} else {
return ERRNO_BADF;
}
},
fd_close(fd) {
if (self.fds[fd] != void 0) {
const ret = self.fds[fd].fd_close();
self.fds[fd] = void 0;
return ret;
} else {
return ERRNO_BADF;
}
},
fd_datasync(fd) {
if (self.fds[fd] != void 0) {
return self.fds[fd].fd_sync();
} else {
return ERRNO_BADF;
}
},
fd_fdstat_get(fd, fdstat_ptr) {
if (self.fds[fd] != void 0) {
const { ret, fdstat } = self.fds[fd].fd_fdstat_get();
if (fdstat != null) {
fdstat.write_bytes(new DataView(self.inst.exports.memory.buffer), fdstat_ptr);
}
return ret;
} else {
return ERRNO_BADF;
}
},
fd_fdstat_set_flags(fd, flags) {
if (self.fds[fd] != void 0) {
return self.fds[fd].fd_fdstat_set_flags(flags);
} else {
return ERRNO_BADF;
}
},
fd_fdstat_set_rights(fd, fs_rights_base, fs_rights_inheriting) {
if (self.fds[fd] != void 0) {
return self.fds[fd].fd_fdstat_set_rights(fs_rights_base, fs_rights_inheriting);
} else {
return ERRNO_BADF;
}
},
fd_filestat_get(fd, filestat_ptr) {
if (self.fds[fd] != void 0) {
const { ret, filestat } = self.fds[fd].fd_filestat_get();
if (filestat != null) {
filestat.write_bytes(new DataView(self.inst.exports.memory.buffer), filestat_ptr);
}
return ret;
} else {
return ERRNO_BADF;
}
},
fd_filestat_set_size(fd, size) {
if (self.fds[fd] != void 0) {
return self.fds[fd].fd_filestat_set_size(size);
} else {
return ERRNO_BADF;
}
},
fd_filestat_set_times(fd, atim, mtim, fst_flags) {
if (self.fds[fd] != void 0) {
return self.fds[fd].fd_filestat_set_times(atim, mtim, fst_flags);
} else {
return ERRNO_BADF;
}
},
fd_pread(fd, iovs_ptr, iovs_len, offset, nread_ptr) {
const buffer = new DataView(self.inst.exports.memory.buffer);
const buffer8 = new Uint8Array(self.inst.exports.memory.buffer);
if (self.fds[fd] != void 0) {
const iovecs = Iovec.read_bytes_array(buffer, iovs_ptr, iovs_len);
let nread = 0;
for (const iovec of iovecs) {
const { ret, data } = self.fds[fd].fd_pread(iovec.buf_len, offset);
if (ret != ERRNO_SUCCESS) {
buffer.setUint32(nread_ptr, nread, true);
return ret;
}
buffer8.set(data, iovec.buf);
nread += data.length;
offset += BigInt(data.length);
if (data.length != iovec.buf_len) {
break;
}
}
buffer.setUint32(nread_ptr, nread, true);
return ERRNO_SUCCESS;
} else {
return ERRNO_BADF;
}
},
fd_prestat_get(fd, buf_ptr) {
const buffer = new DataView(self.inst.exports.memory.buffer);
if (self.fds[fd] != void 0) {
const { ret, prestat } = self.fds[fd].fd_prestat_get();
if (prestat != null) {
prestat.write_bytes(buffer, buf_ptr);
}
return ret;
} else {
return ERRNO_BADF;
}
},
fd_prestat_dir_name(fd, path_ptr, path_len) {
if (self.fds[fd] != void 0) {
const { ret, prestat } = self.fds[fd].fd_prestat_get();
if (prestat == null) {
return ret;
}
const prestat_dir_name = prestat.inner.pr_name;
const buffer8 = new Uint8Array(self.inst.exports.memory.buffer);
buffer8.set(prestat_dir_name.slice(0, path_len), path_ptr);
return prestat_dir_name.byteLength > path_len ? ERRNO_NAMETOOLONG : ERRNO_SUCCESS;
} else {
return ERRNO_BADF;
}
},
fd_pwrite(fd, iovs_ptr, iovs_len, offset, nwritten_ptr) {
const buffer = new DataView(self.inst.exports.memory.buffer);
const buffer8 = new Uint8Array(self.inst.exports.memory.buffer);
if (self.fds[fd] != void 0) {
const iovecs = Ciovec.read_bytes_array(buffer, iovs_ptr, iovs_len);
let nwritten = 0;
for (const iovec of iovecs) {
const data = buffer8.slice(iovec.buf, iovec.buf + iovec.buf_len);
const { ret, nwritten: nwritten_part } = self.fds[fd].fd_pwrite(data, offset);
if (ret != ERRNO_SUCCESS) {
buffer.setUint32(nwritten_ptr, nwritten, true);
return ret;
}
nwritten += nwritten_part;
offset += BigInt(nwritten_part);
if (nwritten_part != data.byteLength) {
break;
}
}
buffer.setUint32(nwritten_ptr, nwritten, true);
return ERRNO_SUCCESS;
} else {
return ERRNO_BADF;
}
},
fd_read(fd, iovs_ptr, iovs_len, nread_ptr) {
const buffer = new DataView(self.inst.exports.memory.buffer);
const buffer8 = new Uint8Array(self.inst.exports.memory.buffer);
if (self.fds[fd] != void 0) {
const iovecs = Iovec.read_bytes_array(buffer, iovs_ptr, iovs_len);
let nread = 0;
for (const iovec of iovecs) {
const { ret, data } = self.fds[fd].fd_read(iovec.buf_len);
if (ret != ERRNO_SUCCESS) {
buffer.setUint32(nread_ptr, nread, true);
return ret;
}
buffer8.set(data, iovec.buf);
nread += data.length;
if (data.length != iovec.buf_len) {
break;
}
}
buffer.setUint32(nread_ptr, nread, true);
return ERRNO_SUCCESS;
} else {
return ERRNO_BADF;
}
},
fd_readdir(fd, buf, buf_len, cookie, bufused_ptr) {
const buffer = new DataView(self.inst.exports.memory.buffer);
const buffer8 = new Uint8Array(self.inst.exports.memory.buffer);
if (self.fds[fd] != void 0) {
let bufused = 0;
while (true) {
const { ret, dirent } = self.fds[fd].fd_readdir_single(cookie);
if (ret != 0) {
buffer.setUint32(bufused_ptr, bufused, true);
return ret;
}
if (dirent == null) {
break;
}
if (buf_len - bufused < dirent.head_length()) {
bufused = buf_len;
break;
}
const head_bytes = new ArrayBuffer(dirent.head_length());
dirent.write_head_bytes(new DataView(head_bytes), 0);
buffer8.set(new Uint8Array(head_bytes).slice(0, Math.min(head_bytes.byteLength, buf_len - bufused)), buf);
buf += dirent.head_length();
bufused += dirent.head_length();
if (buf_len - bufused < dirent.name_length()) {
bufused = buf_len;
break;
}
dirent.write_name_bytes(buffer8, buf, buf_len - bufused);
buf += dirent.name_length();
bufused += dirent.name_length();
cookie = dirent.d_next;
}
buffer.setUint32(bufused_ptr, bufused, true);
return 0;
} else {
return ERRNO_BADF;
}
},
fd_renumber(fd, to) {
if (self.fds[fd] != void 0 && self.fds[to] != void 0) {
const ret = self.fds[to].fd_close();
if (ret != 0) {
return ret;
}
self.fds[to] = self.fds[fd];
self.fds[fd] = void 0;
return 0;
} else {
return ERRNO_BADF;
}
},
fd_seek(fd, offset, whence, offset_out_ptr) {
const buffer = new DataView(self.inst.exports.memory.buffer);
if (self.fds[fd] != void 0) {
const { ret, offset: offset_out } = self.fds[fd].fd_seek(offset, whence);
buffer.setBigInt64(offset_out_ptr, offset_out, true);
return ret;
} else {
return ERRNO_BADF;
}
},
fd_sync(fd) {
if (self.fds[fd] != void 0) {
return self.fds[fd].fd_sync();
} else {
return ERRNO_BADF;
}
},
fd_tell(fd, offset_ptr) {
const buffer = new DataView(self.inst.exports.memory.buffer);
if (self.fds[fd] != void 0) {
const { ret, offset } = self.fds[fd].fd_tell();
buffer.setBigUint64(offset_ptr, offset, true);
return ret;
} else {
return ERRNO_BADF;
}
},
fd_write(fd, iovs_ptr, iovs_len, nwritten_ptr) {
const buffer = new DataView(self.inst.exports.memory.buffer);
const buffer8 = new Uint8Array(self.inst.exports.memory.buffer);
if (self.fds[fd] != void 0) {
const iovecs = Ciovec.read_bytes_array(buffer, iovs_ptr, iovs_len);
let nwritten = 0;
for (const iovec of iovecs) {
const data = buffer8.slice(iovec.buf, iovec.buf + iovec.buf_len);
const { ret, nwritten: nwritten_part } = self.fds[fd].fd_write(data);
if (ret != ERRNO_SUCCESS) {
buffer.setUint32(nwritten_ptr, nwritten, true);
return ret;
}
nwritten += nwritten_part;
if (nwritten_part != data.byteLength) {
break;
}
}
buffer.setUint32(nwritten_ptr, nwritten, true);
return ERRNO_SUCCESS;
} else {
return ERRNO_BADF;
}
},
path_create_directory(fd, path_ptr, path_len) {
const buffer8 = new Uint8Array(self.inst.exports.memory.buffer);
if (self.fds[fd] != void 0) {
const path = new TextDecoder("utf-8").decode(buffer8.slice(path_ptr, path_ptr + path_len));
return self.fds[fd].path_create_directory(path);
} else {
return ERRNO_BADF;
}
},
path_filestat_get(fd, flags, path_ptr, path_len, filestat_ptr) {
const buffer = new DataView(self.inst.exports.memory.buffer);
const buffer8 = new Uint8Array(self.inst.exports.memory.buffer);
if (self.fds[fd] != void 0) {
const path = new TextDecoder("utf-8").decode(buffer8.slice(path_ptr, path_ptr + path_len));
const { ret, filestat } = self.fds[fd].path_filestat_get(flags, path);
if (filestat != null) {
filestat.write_bytes(buffer, filestat_ptr);
}
return ret;
} else {
return ERRNO_BADF;
}
},
path_filestat_set_times(fd, flags, path_ptr, path_len, atim, mtim, fst_flags) {
const buffer8 = new Uint8Array(self.inst.exports.memory.buffer);
if (self.fds[fd] != void 0) {
const path = new TextDecoder("utf-8").decode(buffer8.slice(path_ptr, path_ptr + path_len));
return self.fds[fd].path_filestat_set_times(flags, path, atim, mtim, fst_flags);
} else {
return ERRNO_BADF;
}
},
path_link(old_fd, old_flags, old_path_ptr, old_path_len, new_fd, new_path_ptr, new_path_len) {
const buffer8 = new Uint8Array(self.inst.exports.memory.buffer);
if (self.fds[old_fd] != void 0 && self.fds[new_fd] != void 0) {
const old_path = new TextDecoder("utf-8").decode(buffer8.slice(old_path_ptr, old_path_ptr + old_path_len));
const new_path = new TextDecoder("utf-8").decode(buffer8.slice(new_path_ptr, new_path_ptr + new_path_len));
const { ret, inode_obj } = self.fds[old_fd].path_lookup(old_path, old_flags);
if (inode_obj == null) {
return ret;
}
return self.fds[new_fd].path_link(new_path, inode_obj, false);
} else {
return ERRNO_BADF;
}
},
path_open(fd, dirflags, path_ptr, path_len, oflags, fs_rights_base, fs_rights_inheriting, fd_flags, opened_fd_ptr) {
const buffer = new DataView(self.inst.exports.memory.buffer);
const buffer8 = new Uint8Array(self.inst.exports.memory.buffer);
if (self.fds[fd] != void 0) {
const path = new TextDecoder("utf-8").decode(buffer8.slice(path_ptr, path_ptr + path_len));
debug.log(path);
const { ret, fd_obj } = self.fds[fd].path_open(dirflags, path, oflags, fs_rights_base, fs_rights_inheriting, fd_flags);
if (ret != 0) {
return ret;
}
self.fds.push(fd_obj);
const opened_fd = self.fds.length - 1;
buffer.setUint32(opened_fd_ptr, opened_fd, true);
return 0;
} else {
return ERRNO_BADF;
}
},
path_readlink(fd, path_ptr, path_len, buf_ptr, buf_len, nread_ptr) {
const buffer = new DataView(self.inst.exports.memory.buffer);
const buffer8 = new Uint8Array(self.inst.exports.memory.buffer);
if (self.fds[fd] != void 0) {
const path = new TextDecoder("utf-8").decode(buffer8.slice(path_ptr, path_ptr + path_len));
debug.log(path);
const { ret, data } = self.fds[fd].path_readlink(path);
if (data != null) {
const data_buf = new TextEncoder().encode(data);
if (data_buf.length > buf_len) {
buffer.setUint32(nread_ptr, 0, true);
return ERRNO_BADF;
}
buffer8.set(data_buf, buf_ptr);
buffer.setUint32(nread_ptr, data_buf.length, true);
}
return ret;
} else {
return ERRNO_BADF;
}
},
path_remove_directory(fd, path_ptr, path_len) {
const buffer8 = new Uint8Array(self.inst.exports.memory.buffer);
if (self.fds[fd] != void 0) {
const path = new TextDecoder("utf-8").decode(buffer8.slice(path_ptr, path_ptr + path_len));
return self.fds[fd].path_remove_directory(path);
} else {
return ERRNO_BADF;
}
},
path_rename(fd, old_path_ptr, old_path_len, new_fd, new_path_ptr, new_path_len) {
const buffer8 = new Uint8Array(self.inst.exports.memory.buffer);
if (self.fds[fd] != void 0 && self.fds[new_fd] != void 0) {
const old_path = new TextDecoder("utf-8").decode(buffer8.slice(old_path_ptr, old_path_ptr + old_path_len));
const new_path = new TextDecoder("utf-8").decode(buffer8.slice(new_path_ptr, new_path_ptr + new_path_len));
let { ret, inode_obj } = self.fds[fd].path_unlink(old_path);
if (inode_obj == null) {
return ret;
}
ret = self.fds[new_fd].path_link(new_path, inode_obj, true);
if (ret != ERRNO_SUCCESS) {
if (self.fds[fd].path_link(old_path, inode_obj, true) != ERRNO_SUCCESS) {
throw "path_link should always return success when relinking an inode back to the original place";
}
}
return ret;
} else {
return ERRNO_BADF;
}
},
path_symlink(old_path_ptr, old_path_len, fd, new_path_ptr, new_path_len) {
const buffer8 = new Uint8Array(self.inst.exports.memory.buffer);
if (self.fds[fd] != void 0) {
const old_path = new TextDecoder("utf-8").decode(buffer8.slice(old_path_ptr, old_path_ptr + old_path_len));
const new_path = new TextDecoder("utf-8").decode(buffer8.slice(new_path_ptr, new_path_ptr + new_path_len));
return ERRNO_NOTSUP;
} else {
return ERRNO_BADF;
}
},
path_unlink_file(fd, path_ptr, path_len) {
const buffer8 = new Uint8Array(self.inst.exports.memory.buffer);
if (self.fds[fd] != void 0) {
const path = new TextDecoder("utf-8").decode(buffer8.slice(path_ptr, path_ptr + path_len));
return self.fds[fd].path_unlink_file(path);
} else {
return ERRNO_BADF;
}
},
// eslint-disable-next-line @typescript-eslint/no-unused-vars
poll_oneoff(in_, out, nsubscriptions) {
throw "async io not supported";
},
proc_exit(exit_code) {
throw new WASIProcExit(exit_code);
},
proc_raise(sig) {
throw "raised signal " + sig;
},
sched_yield() {
},
random_get(buf, buf_len) {
const buffer8 = new Uint8Array(self.inst.exports.memory.buffer).subarray(buf, buf + buf_len);
if ("crypto" in globalThis && !(self.inst.exports.memory.buffer instanceof SharedArrayBuffer)) {
for (let i = 0; i < buf_len; i += 65536) {
crypto.getRandomValues(buffer8.subarray(i, i + 65536));
}
} else {
for (let i = 0; i < buf_len; i++) {
buffer8[i] = Math.random() * 256 | 0;
}
}
},
// eslint-disable-next-line @typescript-eslint/no-unused-vars
sock_recv(fd, ri_data, ri_flags) {
throw "sockets not supported";
},
// eslint-disable-next-line @typescript-eslint/no-unused-vars
sock_send(fd, si_data, si_flags) {
throw "sockets not supported";
},
// eslint-disable-next-line @typescript-eslint/no-unused-vars
sock_shutdown(fd, how) {
throw "sockets not supported";
},
// eslint-disable-next-line @typescript-eslint/no-unused-vars
sock_accept(fd, flags) {
throw "sockets not supported";
}
};
}
};
// node_modules/browser_wasi_shim_gaiden/dist/fd.js
var Fd = class {
static {
__name(this, "Fd");
}
fd_allocate(offset, len) {
return ERRNO_NOTSUP;
}
fd_close() {
return 0;
}
fd_fdstat_get() {
return { ret: ERRNO_NOTSUP, fdstat: null };
}
fd_fdstat_set_flags(flags) {
return ERRNO_NOTSUP;
}
fd_fdstat_set_rights(fs_rights_base, fs_rights_inheriting) {
return ERRNO_NOTSUP;
}
fd_filestat_get() {
return { ret: ERRNO_NOTSUP, filestat: null };
}
fd_filestat_set_size(size) {
return ERRNO_NOTSUP;
}
fd_filestat_set_times(atim, mtim, fst_flags) {
return ERRNO_NOTSUP;
}
fd_pread(size, offset) {
return { ret: ERRNO_NOTSUP, data: new Uint8Array() };
}
fd_prestat_get() {
return { ret: ERRNO_NOTSUP, prestat: null };
}
fd_pwrite(data, offset) {
return { ret: ERRNO_NOTSUP, nwritten: 0 };
}
fd_read(size) {
return { ret: ERRNO_NOTSUP, data: new Uint8Array() };
}
fd_readdir_single(cookie) {
return { ret: ERRNO_NOTSUP, dirent: null };
}
fd_seek(offset, whence) {
return { ret: ERRNO_NOTSUP, offset: 0n };
}
fd_sync() {
return 0;
}
fd_tell() {
return { ret: ERRNO_NOTSUP, offset: 0n };
}
fd_write(data) {
return { ret: ERRNO_NOTSUP, nwritten: 0 };
}
path_create_directory(path) {
return ERRNO_NOTSUP;
}
path_filestat_get(flags, path) {
return { ret: ERRNO_NOTSUP, filestat: null };
}
path_filestat_set_times(flags, path, atim, mtim, fst_flags) {
return ERRNO_NOTSUP;
}
path_link(path, inode, allow_dir) {
return ERRNO_NOTSUP;
}
path_unlink(path) {
return { ret: ERRNO_NOTSUP, inode_obj: null };
}
path_lookup(path, dirflags) {
return { ret: ERRNO_NOTSUP, inode_obj: null };
}
path_open(dirflags, path, oflags, fs_rights_base, fs_rights_inheriting, fd_flags) {
return { ret: ERRNO_NOTDIR, fd_obj: null };
}
path_readlink(path) {
return { ret: ERRNO_NOTSUP, data: null };
}
path_remove_directory(path) {
return ERRNO_NOTSUP;
}
path_rename(old_path, new_fd, new_path) {
return ERRNO_NOTSUP;
}
path_unlink_file(path) {
return ERRNO_NOTSUP;
}
};
var Inode = class {
static {
__name(this, "Inode");
}
};
// node_modules/browser_wasi_shim_gaiden/dist/fs_mem.js
var OpenFile = class extends Fd {
static {
__name(this, "OpenFile");
}
file;
file_pos = 0n;
constructor(file) {
super();
this.file = file;
}
fd_allocate(offset, len) {
if (this.file.size > offset + len) {
} else {
const new_data = new Uint8Array(Number(offset + len));
new_data.set(this.file.data, 0);
this.file.data = new_data;
}
return ERRNO_SUCCESS;
}
fd_fdstat_get() {
return { ret: 0, fdstat: new Fdstat(FILETYPE_REGULAR_FILE, 0) };
}
fd_filestat_set_size(size) {
if (this.file.size > size) {
this.file.data = new Uint8Array(this.file.data.buffer.slice(0, Number(size)));
} else {
const new_data = new Uint8Array(Number(size));
new_data.set(this.file.data, 0);
this.file.data = new_data;
}
return ERRNO_SUCCESS;
}
fd_read(size) {
const slice = this.file.data.slice(Number(this.file_pos), Number(this.file_pos + BigInt(size)));
this.file_pos += BigInt(slice.length);
return { ret: 0, data: slice };
}
fd_pread(size, offset) {
const slice = this.file.data.slice(Number(offset), Number(offset + BigInt(size)));
return { ret: 0, data: slice };
}
fd_seek(offset, whence) {
let calculated_offset;
switch (whence) {
case WHENCE_SET:
calculated_offset = offset;
break;
case WHENCE_CUR:
calculated_offset = this.file_pos + offset;
break;
case WHENCE_END:
calculated_offset = BigInt(this.file.data.byteLength) + offset;
break;
default:
return { ret: ERRNO_INVAL, offset: 0n };
}
if (calculated_offset < 0) {
return { ret: ERRNO_INVAL, offset: 0n };
}
this.file_pos = calculated_offset;
return { ret: 0, offset: this.file_pos };
}
fd_tell() {
return { ret: 0, offset: this.file_pos };
}
fd_write(data) {
if (this.file.readonly)
return { ret: ERRNO_BADF, nwritten: 0 };
if (this.file_pos + BigInt(data.byteLength) > this.file.size) {
const old = this.file.data;
this.file.data = new Uint8Array(Number(this.file_pos + BigInt(data.byteLength)));
this.file.data.set(old);
}
this.file.data.set(data, Number(this.file_pos));
this.file_pos += BigInt(data.byteLength);
return { ret: 0, nwritten: data.byteLength };
}
fd_pwrite(data, offset) {
if (this.file.readonly)
return { ret: ERRNO_BADF, nwritten: 0 };
if (offset + BigInt(data.byteLength) > this.file.size) {
const old = this.file.data;
this.file.data = new Uint8Array(Number(offset + BigInt(data.byteLength)));
this.file.data.set(old);
}
this.file.data.set(data, Number(offset));
return { ret: 0, nwritten: data.byteLength };
}
fd_filestat_get() {
return { ret: 0, filestat: this.file.stat() };
}
};
var OpenDirectory = class extends Fd {
static {
__name(this, "OpenDirectory");
}
dir;
constructor(dir) {
super();
this.dir = dir;
}
// eslint-disable-next-line @typescript-eslint/no-unused-vars
fd_seek(offset, whence) {
return { ret: ERRNO_BADF, offset: 0n };
}
fd_tell() {
return { ret: ERRNO_BADF, offset: 0n };
}
// eslint-disable-next-line @typescript-eslint/no-unused-vars
fd_allocate(offset, len) {
return ERRNO_BADF;
}
fd_fdstat_get() {
return { ret: 0, fdstat: new Fdstat(FILETYPE_DIRECTORY, 0) };
}
fd_readdir_single(cookie) {
if (debug.enabled) {
debug.log("readdir_single", cookie);
debug.log(cookie, this.dir.contents.keys());
}
if (cookie == 0n) {
return {
ret: ERRNO_SUCCESS,
dirent: new Dirent(1n, ".", FILETYPE_DIRECTORY)
};
} else if (cookie == 1n) {
return {
ret: ERRNO_SUCCESS,
dirent: new Dirent(2n, "..", FILETYPE_DIRECTORY)
};
}
if (cookie >= BigInt(this.dir.contents.size) + 2n) {
return { ret: 0, dirent: null };
}
const [name, entry] = Array.from(this.dir.contents.entries())[Number(cookie - 2n)];
return {
ret: 0,
dirent: new Dirent(cookie + 1n, name, entry.stat().filetype)
};
}
path_filestat_get(flags, path_str) {
const { ret: path_err, path } = Path.from(path_str);
if (path == null) {
return { ret: path_err, filestat: null };
}
const { ret, entry } = this.dir.get_entry_for_path(path);
if (entry == null) {
return { ret, filestat: null };
}
return { ret: 0, filestat: entry.stat() };
}
path_lookup(path_str, dirflags) {
const { ret: path_ret, path } = Path.from(path_str);
if (path == null) {
return { ret: path_ret, inode_obj: null };
}
const { ret, entry } = this.dir.get_entry_for_path(path);
if (entry == null) {
return { ret, inode_obj: null };
}
return { ret: ERRNO_SUCCESS, inode_obj: entry };
}
path_open(dirflags, path_str, oflags, fs_rights_base, fs_rights_inheriting, fd_flags) {
const { ret: path_ret, path } = Path.from(path_str);
if (path == null) {
return { ret: path_ret, fd_obj: null };
}
let { ret, entry } = this.dir.get_entry_for_path(path);
if (entry == null) {
if (ret != ERRNO_NOENT) {
return { ret, fd_obj: null };
}
if ((oflags & OFLAGS_CREAT) == OFLAGS_CREAT) {
const { ret: ret2, entry: new_entry } = this.dir.create_entry_for_path(path_str, (oflags & OFLAGS_DIRECTORY) == OFLAGS_DIRECTORY);
if (new_entry == null) {
return { ret: ret2, fd_obj: null };
}
entry = new_entry;
} else {
return { ret: ERRNO_NOENT, fd_obj: null };
}
} else if ((oflags & OFLAGS_EXCL) == OFLAGS_EXCL) {
return { ret: ERRNO_EXIST, fd_obj: null };
}
if ((oflags & OFLAGS_DIRECTORY) == OFLAGS_DIRECTORY && entry.stat().filetype !== FILETYPE_DIRECTORY) {
return { ret: ERRNO_NOTDIR, fd_obj: null };
}
return entry.path_open(oflags, fs_rights_base, fd_flags);
}
path_create_directory(path) {
return this.path_open(0, path, OFLAGS_CREAT | OFLAGS_DIRECTORY, 0n, 0n, 0).ret;
}
path_link(path_str, inode, allow_dir) {
const { ret: path_ret, path } = Path.from(path_str);
if (path == null) {
return path_ret;
}
if (path.is_dir) {
return ERRNO_NOENT;
}
const { ret: parent_ret, parent_entry, filename, entry } = this.dir.get_parent_dir_and_entry_for_path(path, true);
if (parent_entry == null || filename == null) {
return parent_ret;
}
if (entry != null) {
const source_is_dir = inode.stat().filetype == FILETYPE_DIRECTORY;
const target_is_dir = entry.stat().filetype == FILETYPE_DIRECTORY;
if (source_is_dir && target_is_dir) {
if (allow_dir && entry instanceof Directory) {
if (entry.contents.size == 0) {
} else {
return ERRNO_NOTEMPTY;