@bytecodealliance/jco
Version:
JavaScript tooling for working with WebAssembly Components
2,170 lines (2,108 loc) • 117 kB
JavaScript
import { environment, exit as exit$1, stderr, stdin, stdout, terminalInput, terminalOutput, terminalStderr, terminalStdin, terminalStdout } from '@bytecodealliance/preview2-shim/cli';
import { preopens, types } from '@bytecodealliance/preview2-shim/filesystem';
import { error, streams } from '@bytecodealliance/preview2-shim/io';
import { random } from '@bytecodealliance/preview2-shim/random';
const { getEnvironment } = environment;
const { exit } = exit$1;
const { getStderr } = stderr;
const { getStdin } = stdin;
const { getStdout } = stdout;
const { TerminalInput } = terminalInput;
const { TerminalOutput } = terminalOutput;
const { getTerminalStderr } = terminalStderr;
const { getTerminalStdin } = terminalStdin;
const { getTerminalStdout } = terminalStdout;
const { getDirectories } = preopens;
const { Descriptor,
DirectoryEntryStream,
filesystemErrorCode } = types;
const { Error: Error$1 } = error;
const { InputStream,
OutputStream } = streams;
const { getRandomBytes } = random;
let dv = new DataView(new ArrayBuffer());
const dataView = mem => dv.buffer === mem.buffer ? dv : dv = new DataView(mem.buffer);
const toUint64 = val => BigInt.asUintN(64, BigInt(val));
function toUint32(val) {
return val >>> 0;
}
const utf8Decoder = new TextDecoder();
const utf8Encoder = new TextEncoder();
let utf8EncodedLen = 0;
function utf8Encode(s, realloc, memory) {
if (typeof s !== 'string') throw new TypeError('expected a string');
if (s.length === 0) {
utf8EncodedLen = 0;
return 1;
}
let buf = utf8Encoder.encode(s);
let ptr = realloc(0, 0, 1, buf.length);
new Uint8Array(memory.buffer).set(buf, ptr);
utf8EncodedLen = buf.length;
return ptr;
}
const T_FLAG = 1 << 30;
function rscTableCreateOwn (table, rep) {
const free = table[0] & ~T_FLAG;
if (free === 0) {
table.push(0);
table.push(rep | T_FLAG);
return (table.length >> 1) - 1;
}
table[0] = table[free << 1];
table[free << 1] = 0;
table[(free << 1) + 1] = rep | T_FLAG;
return free;
}
function rscTableRemove (table, handle) {
const scope = table[handle << 1];
const val = table[(handle << 1) + 1];
const own = (val & T_FLAG) !== 0;
const rep = val & ~T_FLAG;
if (val === 0 || (scope & T_FLAG) !== 0) throw new TypeError('Invalid handle');
table[handle << 1] = table[0] | T_FLAG;
table[0] = handle | T_FLAG;
return { rep, scope, own };
}
let curResourceBorrows = [];
const _debugLog = (...args) => {
if (!globalThis?.process?.env?.JCO_DEBUG) { return; }
console.debug(...args);
}
const base64Compile = str => WebAssembly.compile(typeof Buffer !== 'undefined' ? Buffer.from(str, 'base64') : Uint8Array.from(atob(str), b => b.charCodeAt(0)));
const isNode = typeof process !== 'undefined' && process.versions && process.versions.node;
let _fs;
async function fetchCompile (url) {
if (isNode) {
_fs = _fs || await import('node:fs/promises');
return WebAssembly.compile(await _fs.readFile(url));
}
return fetch(url).then(WebAssembly.compileStreaming);
}
const symbolCabiDispose = Symbol.for('cabiDispose');
const symbolRscHandle = Symbol('handle');
const symbolRscRep = Symbol.for('cabiRep');
const symbolDispose = Symbol.dispose || Symbol.for('dispose');
const handleTables = [];
class ComponentError extends Error {
constructor (value) {
const enumerable = typeof value !== 'string';
super(enumerable ? `${String(value)} (see error.payload)` : value);
Object.defineProperty(this, 'payload', { value, enumerable });
}
}
function getErrorPayload(e) {
if (e && hasOwnProperty.call(e, 'payload')) return e.payload;
if (e instanceof Error) throw e;
return e;
}
function throwUninitialized() {
throw new TypeError('Wasm uninitialized use `await $init` first');
}
const hasOwnProperty = Object.prototype.hasOwnProperty;
const instantiateCore = WebAssembly.instantiate;
let exports0;
let exports1;
const handleTable2 = [T_FLAG, 0];
const captureTable2= new Map();
let captureCnt2 = 0;
handleTables[2] = handleTable2;
function trampoline5() {
const ret = getStderr();
if (!(ret instanceof OutputStream)) {
throw new TypeError('Resource error: Not a valid "OutputStream" resource.');
}
var handle0 = ret[symbolRscHandle];
if (!handle0) {
const rep = ret[symbolRscRep] || ++captureCnt2;
captureTable2.set(rep, ret);
handle0 = rscTableCreateOwn(handleTable2, rep);
}
return handle0;
}
const handleTable1 = [T_FLAG, 0];
const captureTable1= new Map();
let captureCnt1 = 0;
handleTables[1] = handleTable1;
function trampoline8() {
const ret = getStdin();
if (!(ret instanceof InputStream)) {
throw new TypeError('Resource error: Not a valid "InputStream" resource.');
}
var handle0 = ret[symbolRscHandle];
if (!handle0) {
const rep = ret[symbolRscRep] || ++captureCnt1;
captureTable1.set(rep, ret);
handle0 = rscTableCreateOwn(handleTable1, rep);
}
return handle0;
}
function trampoline9() {
const ret = getStdout();
if (!(ret instanceof OutputStream)) {
throw new TypeError('Resource error: Not a valid "OutputStream" resource.');
}
var handle0 = ret[symbolRscHandle];
if (!handle0) {
const rep = ret[symbolRscRep] || ++captureCnt2;
captureTable2.set(rep, ret);
handle0 = rscTableCreateOwn(handleTable2, rep);
}
return handle0;
}
function trampoline10(arg0) {
let variant0;
switch (arg0) {
case 0: {
variant0= {
tag: 'ok',
val: undefined
};
break;
}
case 1: {
variant0= {
tag: 'err',
val: undefined
};
break;
}
default: {
throw new TypeError('invalid variant discriminant for expected');
}
}
exit(variant0);
}
let exports2;
let memory0;
let realloc0;
function trampoline11(arg0) {
const ret = getEnvironment();
var vec3 = ret;
var len3 = vec3.length;
var result3 = realloc0(0, 0, 4, len3 * 16);
for (let i = 0; i < vec3.length; i++) {
const e = vec3[i];
const base = result3 + i * 16;var [tuple0_0, tuple0_1] = e;
var ptr1 = utf8Encode(tuple0_0, realloc0, memory0);
var len1 = utf8EncodedLen;
dataView(memory0).setInt32(base + 4, len1, true);
dataView(memory0).setInt32(base + 0, ptr1, true);
var ptr2 = utf8Encode(tuple0_1, realloc0, memory0);
var len2 = utf8EncodedLen;
dataView(memory0).setInt32(base + 12, len2, true);
dataView(memory0).setInt32(base + 8, ptr2, true);
}
dataView(memory0).setInt32(arg0 + 4, len3, true);
dataView(memory0).setInt32(arg0 + 0, result3, true);
}
const handleTable6 = [T_FLAG, 0];
const captureTable6= new Map();
let captureCnt6 = 0;
handleTables[6] = handleTable6;
function trampoline12(arg0, arg1) {
var handle1 = arg0;
var rep2 = handleTable6[(handle1 << 1) + 1] & ~T_FLAG;
var rsc0 = captureTable6.get(rep2);
if (!rsc0) {
rsc0 = Object.create(Descriptor.prototype);
Object.defineProperty(rsc0, symbolRscHandle, { writable: true, value: handle1});
Object.defineProperty(rsc0, symbolRscRep, { writable: true, value: rep2});
}
curResourceBorrows.push(rsc0);
let ret;
try {
ret = { tag: 'ok', val: rsc0.getType()};
} catch (e) {
ret = { tag: 'err', val: getErrorPayload(e) };
}
for (const rsc of curResourceBorrows) {
rsc[symbolRscHandle] = undefined;
}
curResourceBorrows = [];
var variant5 = ret;
switch (variant5.tag) {
case 'ok': {
const e = variant5.val;
dataView(memory0).setInt8(arg1 + 0, 0, true);
var val3 = e;
let enum3;
switch (val3) {
case 'unknown': {
enum3 = 0;
break;
}
case 'block-device': {
enum3 = 1;
break;
}
case 'character-device': {
enum3 = 2;
break;
}
case 'directory': {
enum3 = 3;
break;
}
case 'fifo': {
enum3 = 4;
break;
}
case 'symbolic-link': {
enum3 = 5;
break;
}
case 'regular-file': {
enum3 = 6;
break;
}
case 'socket': {
enum3 = 7;
break;
}
default: {
if ((e) instanceof Error) {
console.error(e);
}
throw new TypeError(`"${val3}" is not one of the cases of descriptor-type`);
}
}
dataView(memory0).setInt8(arg1 + 1, enum3, true);
break;
}
case 'err': {
const e = variant5.val;
dataView(memory0).setInt8(arg1 + 0, 1, true);
var val4 = e;
let enum4;
switch (val4) {
case 'access': {
enum4 = 0;
break;
}
case 'would-block': {
enum4 = 1;
break;
}
case 'already': {
enum4 = 2;
break;
}
case 'bad-descriptor': {
enum4 = 3;
break;
}
case 'busy': {
enum4 = 4;
break;
}
case 'deadlock': {
enum4 = 5;
break;
}
case 'quota': {
enum4 = 6;
break;
}
case 'exist': {
enum4 = 7;
break;
}
case 'file-too-large': {
enum4 = 8;
break;
}
case 'illegal-byte-sequence': {
enum4 = 9;
break;
}
case 'in-progress': {
enum4 = 10;
break;
}
case 'interrupted': {
enum4 = 11;
break;
}
case 'invalid': {
enum4 = 12;
break;
}
case 'io': {
enum4 = 13;
break;
}
case 'is-directory': {
enum4 = 14;
break;
}
case 'loop': {
enum4 = 15;
break;
}
case 'too-many-links': {
enum4 = 16;
break;
}
case 'message-size': {
enum4 = 17;
break;
}
case 'name-too-long': {
enum4 = 18;
break;
}
case 'no-device': {
enum4 = 19;
break;
}
case 'no-entry': {
enum4 = 20;
break;
}
case 'no-lock': {
enum4 = 21;
break;
}
case 'insufficient-memory': {
enum4 = 22;
break;
}
case 'insufficient-space': {
enum4 = 23;
break;
}
case 'not-directory': {
enum4 = 24;
break;
}
case 'not-empty': {
enum4 = 25;
break;
}
case 'not-recoverable': {
enum4 = 26;
break;
}
case 'unsupported': {
enum4 = 27;
break;
}
case 'no-tty': {
enum4 = 28;
break;
}
case 'no-such-device': {
enum4 = 29;
break;
}
case 'overflow': {
enum4 = 30;
break;
}
case 'not-permitted': {
enum4 = 31;
break;
}
case 'pipe': {
enum4 = 32;
break;
}
case 'read-only': {
enum4 = 33;
break;
}
case 'invalid-seek': {
enum4 = 34;
break;
}
case 'text-file-busy': {
enum4 = 35;
break;
}
case 'cross-device': {
enum4 = 36;
break;
}
default: {
if ((e) instanceof Error) {
console.error(e);
}
throw new TypeError(`"${val4}" is not one of the cases of error-code`);
}
}
dataView(memory0).setInt8(arg1 + 1, enum4, true);
break;
}
default: {
throw new TypeError('invalid variant specified for result');
}
}
}
function trampoline13(arg0, arg1) {
var handle1 = arg0;
var rep2 = handleTable6[(handle1 << 1) + 1] & ~T_FLAG;
var rsc0 = captureTable6.get(rep2);
if (!rsc0) {
rsc0 = Object.create(Descriptor.prototype);
Object.defineProperty(rsc0, symbolRscHandle, { writable: true, value: handle1});
Object.defineProperty(rsc0, symbolRscRep, { writable: true, value: rep2});
}
curResourceBorrows.push(rsc0);
let ret;
try {
ret = { tag: 'ok', val: rsc0.metadataHash()};
} catch (e) {
ret = { tag: 'err', val: getErrorPayload(e) };
}
for (const rsc of curResourceBorrows) {
rsc[symbolRscHandle] = undefined;
}
curResourceBorrows = [];
var variant5 = ret;
switch (variant5.tag) {
case 'ok': {
const e = variant5.val;
dataView(memory0).setInt8(arg1 + 0, 0, true);
var {lower: v3_0, upper: v3_1 } = e;
dataView(memory0).setBigInt64(arg1 + 8, toUint64(v3_0), true);
dataView(memory0).setBigInt64(arg1 + 16, toUint64(v3_1), true);
break;
}
case 'err': {
const e = variant5.val;
dataView(memory0).setInt8(arg1 + 0, 1, true);
var val4 = e;
let enum4;
switch (val4) {
case 'access': {
enum4 = 0;
break;
}
case 'would-block': {
enum4 = 1;
break;
}
case 'already': {
enum4 = 2;
break;
}
case 'bad-descriptor': {
enum4 = 3;
break;
}
case 'busy': {
enum4 = 4;
break;
}
case 'deadlock': {
enum4 = 5;
break;
}
case 'quota': {
enum4 = 6;
break;
}
case 'exist': {
enum4 = 7;
break;
}
case 'file-too-large': {
enum4 = 8;
break;
}
case 'illegal-byte-sequence': {
enum4 = 9;
break;
}
case 'in-progress': {
enum4 = 10;
break;
}
case 'interrupted': {
enum4 = 11;
break;
}
case 'invalid': {
enum4 = 12;
break;
}
case 'io': {
enum4 = 13;
break;
}
case 'is-directory': {
enum4 = 14;
break;
}
case 'loop': {
enum4 = 15;
break;
}
case 'too-many-links': {
enum4 = 16;
break;
}
case 'message-size': {
enum4 = 17;
break;
}
case 'name-too-long': {
enum4 = 18;
break;
}
case 'no-device': {
enum4 = 19;
break;
}
case 'no-entry': {
enum4 = 20;
break;
}
case 'no-lock': {
enum4 = 21;
break;
}
case 'insufficient-memory': {
enum4 = 22;
break;
}
case 'insufficient-space': {
enum4 = 23;
break;
}
case 'not-directory': {
enum4 = 24;
break;
}
case 'not-empty': {
enum4 = 25;
break;
}
case 'not-recoverable': {
enum4 = 26;
break;
}
case 'unsupported': {
enum4 = 27;
break;
}
case 'no-tty': {
enum4 = 28;
break;
}
case 'no-such-device': {
enum4 = 29;
break;
}
case 'overflow': {
enum4 = 30;
break;
}
case 'not-permitted': {
enum4 = 31;
break;
}
case 'pipe': {
enum4 = 32;
break;
}
case 'read-only': {
enum4 = 33;
break;
}
case 'invalid-seek': {
enum4 = 34;
break;
}
case 'text-file-busy': {
enum4 = 35;
break;
}
case 'cross-device': {
enum4 = 36;
break;
}
default: {
if ((e) instanceof Error) {
console.error(e);
}
throw new TypeError(`"${val4}" is not one of the cases of error-code`);
}
}
dataView(memory0).setInt8(arg1 + 8, enum4, true);
break;
}
default: {
throw new TypeError('invalid variant specified for result');
}
}
}
const handleTable0 = [T_FLAG, 0];
const captureTable0= new Map();
let captureCnt0 = 0;
handleTables[0] = handleTable0;
function trampoline14(arg0, arg1) {
var handle1 = arg0;
var rep2 = handleTable0[(handle1 << 1) + 1] & ~T_FLAG;
var rsc0 = captureTable0.get(rep2);
if (!rsc0) {
rsc0 = Object.create(Error$1.prototype);
Object.defineProperty(rsc0, symbolRscHandle, { writable: true, value: handle1});
Object.defineProperty(rsc0, symbolRscRep, { writable: true, value: rep2});
}
curResourceBorrows.push(rsc0);
const ret = filesystemErrorCode(rsc0);
for (const rsc of curResourceBorrows) {
rsc[symbolRscHandle] = undefined;
}
curResourceBorrows = [];
var variant4 = ret;
if (variant4 === null || variant4=== undefined) {
dataView(memory0).setInt8(arg1 + 0, 0, true);
} else {
const e = variant4;
dataView(memory0).setInt8(arg1 + 0, 1, true);
var val3 = e;
let enum3;
switch (val3) {
case 'access': {
enum3 = 0;
break;
}
case 'would-block': {
enum3 = 1;
break;
}
case 'already': {
enum3 = 2;
break;
}
case 'bad-descriptor': {
enum3 = 3;
break;
}
case 'busy': {
enum3 = 4;
break;
}
case 'deadlock': {
enum3 = 5;
break;
}
case 'quota': {
enum3 = 6;
break;
}
case 'exist': {
enum3 = 7;
break;
}
case 'file-too-large': {
enum3 = 8;
break;
}
case 'illegal-byte-sequence': {
enum3 = 9;
break;
}
case 'in-progress': {
enum3 = 10;
break;
}
case 'interrupted': {
enum3 = 11;
break;
}
case 'invalid': {
enum3 = 12;
break;
}
case 'io': {
enum3 = 13;
break;
}
case 'is-directory': {
enum3 = 14;
break;
}
case 'loop': {
enum3 = 15;
break;
}
case 'too-many-links': {
enum3 = 16;
break;
}
case 'message-size': {
enum3 = 17;
break;
}
case 'name-too-long': {
enum3 = 18;
break;
}
case 'no-device': {
enum3 = 19;
break;
}
case 'no-entry': {
enum3 = 20;
break;
}
case 'no-lock': {
enum3 = 21;
break;
}
case 'insufficient-memory': {
enum3 = 22;
break;
}
case 'insufficient-space': {
enum3 = 23;
break;
}
case 'not-directory': {
enum3 = 24;
break;
}
case 'not-empty': {
enum3 = 25;
break;
}
case 'not-recoverable': {
enum3 = 26;
break;
}
case 'unsupported': {
enum3 = 27;
break;
}
case 'no-tty': {
enum3 = 28;
break;
}
case 'no-such-device': {
enum3 = 29;
break;
}
case 'overflow': {
enum3 = 30;
break;
}
case 'not-permitted': {
enum3 = 31;
break;
}
case 'pipe': {
enum3 = 32;
break;
}
case 'read-only': {
enum3 = 33;
break;
}
case 'invalid-seek': {
enum3 = 34;
break;
}
case 'text-file-busy': {
enum3 = 35;
break;
}
case 'cross-device': {
enum3 = 36;
break;
}
default: {
if ((e) instanceof Error) {
console.error(e);
}
throw new TypeError(`"${val3}" is not one of the cases of error-code`);
}
}
dataView(memory0).setInt8(arg1 + 1, enum3, true);
}
}
function trampoline15(arg0, arg1, arg2, arg3, arg4) {
var handle1 = arg0;
var rep2 = handleTable6[(handle1 << 1) + 1] & ~T_FLAG;
var rsc0 = captureTable6.get(rep2);
if (!rsc0) {
rsc0 = Object.create(Descriptor.prototype);
Object.defineProperty(rsc0, symbolRscHandle, { writable: true, value: handle1});
Object.defineProperty(rsc0, symbolRscRep, { writable: true, value: rep2});
}
curResourceBorrows.push(rsc0);
if ((arg1 & 4294967294) !== 0) {
throw new TypeError('flags have extraneous bits set');
}
var flags3 = {
symlinkFollow: Boolean(arg1 & 1),
};
var ptr4 = arg2;
var len4 = arg3;
var result4 = utf8Decoder.decode(new Uint8Array(memory0.buffer, ptr4, len4));
let ret;
try {
ret = { tag: 'ok', val: rsc0.metadataHashAt(flags3, result4)};
} catch (e) {
ret = { tag: 'err', val: getErrorPayload(e) };
}
for (const rsc of curResourceBorrows) {
rsc[symbolRscHandle] = undefined;
}
curResourceBorrows = [];
var variant7 = ret;
switch (variant7.tag) {
case 'ok': {
const e = variant7.val;
dataView(memory0).setInt8(arg4 + 0, 0, true);
var {lower: v5_0, upper: v5_1 } = e;
dataView(memory0).setBigInt64(arg4 + 8, toUint64(v5_0), true);
dataView(memory0).setBigInt64(arg4 + 16, toUint64(v5_1), true);
break;
}
case 'err': {
const e = variant7.val;
dataView(memory0).setInt8(arg4 + 0, 1, true);
var val6 = e;
let enum6;
switch (val6) {
case 'access': {
enum6 = 0;
break;
}
case 'would-block': {
enum6 = 1;
break;
}
case 'already': {
enum6 = 2;
break;
}
case 'bad-descriptor': {
enum6 = 3;
break;
}
case 'busy': {
enum6 = 4;
break;
}
case 'deadlock': {
enum6 = 5;
break;
}
case 'quota': {
enum6 = 6;
break;
}
case 'exist': {
enum6 = 7;
break;
}
case 'file-too-large': {
enum6 = 8;
break;
}
case 'illegal-byte-sequence': {
enum6 = 9;
break;
}
case 'in-progress': {
enum6 = 10;
break;
}
case 'interrupted': {
enum6 = 11;
break;
}
case 'invalid': {
enum6 = 12;
break;
}
case 'io': {
enum6 = 13;
break;
}
case 'is-directory': {
enum6 = 14;
break;
}
case 'loop': {
enum6 = 15;
break;
}
case 'too-many-links': {
enum6 = 16;
break;
}
case 'message-size': {
enum6 = 17;
break;
}
case 'name-too-long': {
enum6 = 18;
break;
}
case 'no-device': {
enum6 = 19;
break;
}
case 'no-entry': {
enum6 = 20;
break;
}
case 'no-lock': {
enum6 = 21;
break;
}
case 'insufficient-memory': {
enum6 = 22;
break;
}
case 'insufficient-space': {
enum6 = 23;
break;
}
case 'not-directory': {
enum6 = 24;
break;
}
case 'not-empty': {
enum6 = 25;
break;
}
case 'not-recoverable': {
enum6 = 26;
break;
}
case 'unsupported': {
enum6 = 27;
break;
}
case 'no-tty': {
enum6 = 28;
break;
}
case 'no-such-device': {
enum6 = 29;
break;
}
case 'overflow': {
enum6 = 30;
break;
}
case 'not-permitted': {
enum6 = 31;
break;
}
case 'pipe': {
enum6 = 32;
break;
}
case 'read-only': {
enum6 = 33;
break;
}
case 'invalid-seek': {
enum6 = 34;
break;
}
case 'text-file-busy': {
enum6 = 35;
break;
}
case 'cross-device': {
enum6 = 36;
break;
}
default: {
if ((e) instanceof Error) {
console.error(e);
}
throw new TypeError(`"${val6}" is not one of the cases of error-code`);
}
}
dataView(memory0).setInt8(arg4 + 8, enum6, true);
break;
}
default: {
throw new TypeError('invalid variant specified for result');
}
}
}
function trampoline16(arg0, arg1, arg2) {
var handle1 = arg0;
var rep2 = handleTable6[(handle1 << 1) + 1] & ~T_FLAG;
var rsc0 = captureTable6.get(rep2);
if (!rsc0) {
rsc0 = Object.create(Descriptor.prototype);
Object.defineProperty(rsc0, symbolRscHandle, { writable: true, value: handle1});
Object.defineProperty(rsc0, symbolRscRep, { writable: true, value: rep2});
}
curResourceBorrows.push(rsc0);
let ret;
try {
ret = { tag: 'ok', val: rsc0.readViaStream(BigInt.asUintN(64, arg1))};
} catch (e) {
ret = { tag: 'err', val: getErrorPayload(e) };
}
for (const rsc of curResourceBorrows) {
rsc[symbolRscHandle] = undefined;
}
curResourceBorrows = [];
var variant5 = ret;
switch (variant5.tag) {
case 'ok': {
const e = variant5.val;
dataView(memory0).setInt8(arg2 + 0, 0, true);
if (!(e instanceof InputStream)) {
throw new TypeError('Resource error: Not a valid "InputStream" resource.');
}
var handle3 = e[symbolRscHandle];
if (!handle3) {
const rep = e[symbolRscRep] || ++captureCnt1;
captureTable1.set(rep, e);
handle3 = rscTableCreateOwn(handleTable1, rep);
}
dataView(memory0).setInt32(arg2 + 4, handle3, true);
break;
}
case 'err': {
const e = variant5.val;
dataView(memory0).setInt8(arg2 + 0, 1, true);
var val4 = e;
let enum4;
switch (val4) {
case 'access': {
enum4 = 0;
break;
}
case 'would-block': {
enum4 = 1;
break;
}
case 'already': {
enum4 = 2;
break;
}
case 'bad-descriptor': {
enum4 = 3;
break;
}
case 'busy': {
enum4 = 4;
break;
}
case 'deadlock': {
enum4 = 5;
break;
}
case 'quota': {
enum4 = 6;
break;
}
case 'exist': {
enum4 = 7;
break;
}
case 'file-too-large': {
enum4 = 8;
break;
}
case 'illegal-byte-sequence': {
enum4 = 9;
break;
}
case 'in-progress': {
enum4 = 10;
break;
}
case 'interrupted': {
enum4 = 11;
break;
}
case 'invalid': {
enum4 = 12;
break;
}
case 'io': {
enum4 = 13;
break;
}
case 'is-directory': {
enum4 = 14;
break;
}
case 'loop': {
enum4 = 15;
break;
}
case 'too-many-links': {
enum4 = 16;
break;
}
case 'message-size': {
enum4 = 17;
break;
}
case 'name-too-long': {
enum4 = 18;
break;
}
case 'no-device': {
enum4 = 19;
break;
}
case 'no-entry': {
enum4 = 20;
break;
}
case 'no-lock': {
enum4 = 21;
break;
}
case 'insufficient-memory': {
enum4 = 22;
break;
}
case 'insufficient-space': {
enum4 = 23;
break;
}
case 'not-directory': {
enum4 = 24;
break;
}
case 'not-empty': {
enum4 = 25;
break;
}
case 'not-recoverable': {
enum4 = 26;
break;
}
case 'unsupported': {
enum4 = 27;
break;
}
case 'no-tty': {
enum4 = 28;
break;
}
case 'no-such-device': {
enum4 = 29;
break;
}
case 'overflow': {
enum4 = 30;
break;
}
case 'not-permitted': {
enum4 = 31;
break;
}
case 'pipe': {
enum4 = 32;
break;
}
case 'read-only': {
enum4 = 33;
break;
}
case 'invalid-seek': {
enum4 = 34;
break;
}
case 'text-file-busy': {
enum4 = 35;
break;
}
case 'cross-device': {
enum4 = 36;
break;
}
default: {
if ((e) instanceof Error) {
console.error(e);
}
throw new TypeError(`"${val4}" is not one of the cases of error-code`);
}
}
dataView(memory0).setInt8(arg2 + 4, enum4, true);
break;
}
default: {
throw new TypeError('invalid variant specified for result');
}
}
}
function trampoline17(arg0, arg1, arg2) {
var handle1 = arg0;
var rep2 = handleTable6[(handle1 << 1) + 1] & ~T_FLAG;
var rsc0 = captureTable6.get(rep2);
if (!rsc0) {
rsc0 = Object.create(Descriptor.prototype);
Object.defineProperty(rsc0, symbolRscHandle, { writable: true, value: handle1});
Object.defineProperty(rsc0, symbolRscRep, { writable: true, value: rep2});
}
curResourceBorrows.push(rsc0);
let ret;
try {
ret = { tag: 'ok', val: rsc0.writeViaStream(BigInt.asUintN(64, arg1))};
} catch (e) {
ret = { tag: 'err', val: getErrorPayload(e) };
}
for (const rsc of curResourceBorrows) {
rsc[symbolRscHandle] = undefined;
}
curResourceBorrows = [];
var variant5 = ret;
switch (variant5.tag) {
case 'ok': {
const e = variant5.val;
dataView(memory0).setInt8(arg2 + 0, 0, true);
if (!(e instanceof OutputStream)) {
throw new TypeError('Resource error: Not a valid "OutputStream" resource.');
}
var handle3 = e[symbolRscHandle];
if (!handle3) {
const rep = e[symbolRscRep] || ++captureCnt2;
captureTable2.set(rep, e);
handle3 = rscTableCreateOwn(handleTable2, rep);
}
dataView(memory0).setInt32(arg2 + 4, handle3, true);
break;
}
case 'err': {
const e = variant5.val;
dataView(memory0).setInt8(arg2 + 0, 1, true);
var val4 = e;
let enum4;
switch (val4) {
case 'access': {
enum4 = 0;
break;
}
case 'would-block': {
enum4 = 1;
break;
}
case 'already': {
enum4 = 2;
break;
}
case 'bad-descriptor': {
enum4 = 3;
break;
}
case 'busy': {
enum4 = 4;
break;
}
case 'deadlock': {
enum4 = 5;
break;
}
case 'quota': {
enum4 = 6;
break;
}
case 'exist': {
enum4 = 7;
break;
}
case 'file-too-large': {
enum4 = 8;
break;
}
case 'illegal-byte-sequence': {
enum4 = 9;
break;
}
case 'in-progress': {
enum4 = 10;
break;
}
case 'interrupted': {
enum4 = 11;
break;
}
case 'invalid': {
enum4 = 12;
break;
}
case 'io': {
enum4 = 13;
break;
}
case 'is-directory': {
enum4 = 14;
break;
}
case 'loop': {
enum4 = 15;
break;
}
case 'too-many-links': {
enum4 = 16;
break;
}
case 'message-size': {
enum4 = 17;
break;
}
case 'name-too-long': {
enum4 = 18;
break;
}
case 'no-device': {
enum4 = 19;
break;
}
case 'no-entry': {
enum4 = 20;
break;
}
case 'no-lock': {
enum4 = 21;
break;
}
case 'insufficient-memory': {
enum4 = 22;
break;
}
case 'insufficient-space': {
enum4 = 23;
break;
}
case 'not-directory': {
enum4 = 24;
break;
}
case 'not-empty': {
enum4 = 25;
break;
}
case 'not-recoverable': {
enum4 = 26;
break;
}
case 'unsupported': {
enum4 = 27;
break;
}
case 'no-tty': {
enum4 = 28;
break;
}
case 'no-such-device': {
enum4 = 29;
break;
}
case 'overflow': {
enum4 = 30;
break;
}
case 'not-permitted': {
enum4 = 31;
break;
}
case 'pipe': {
enum4 = 32;
break;
}
case 'read-only': {
enum4 = 33;
break;
}
case 'invalid-seek': {
enum4 = 34;
break;
}
case 'text-file-busy': {
enum4 = 35;
break;
}
case 'cross-device': {
enum4 = 36;
break;
}
default: {
if ((e) instanceof Error) {
console.error(e);
}
throw new TypeError(`"${val4}" is not one of the cases of error-code`);
}
}
dataView(memory0).setInt8(arg2 + 4, enum4, true);
break;
}
default: {
throw new TypeError('invalid variant specified for result');
}
}
}
function trampoline18(arg0, arg1) {
var handle1 = arg0;
var rep2 = handleTable6[(handle1 << 1) + 1] & ~T_FLAG;
var rsc0 = captureTable6.get(rep2);
if (!rsc0) {
rsc0 = Object.create(Descriptor.prototype);
Object.defineProperty(rsc0, symbolRscHandle, { writable: true, value: handle1});
Object.defineProperty(rsc0, symbolRscRep, { writable: true, value: rep2});
}
curResourceBorrows.push(rsc0);
let ret;
try {
ret = { tag: 'ok', val: rsc0.appendViaStream()};
} catch (e) {
ret = { tag: 'err', val: getErrorPayload(e) };
}
for (const rsc of curResourceBorrows) {
rsc[symbolRscHandle] = undefined;
}
curResourceBorrows = [];
var variant5 = ret;
switch (variant5.tag) {
case 'ok': {
const e = variant5.val;
dataView(memory0).setInt8(arg1 + 0, 0, true);
if (!(e instanceof OutputStream)) {
throw new TypeError('Resource error: Not a valid "OutputStream" resource.');
}
var handle3 = e[symbolRscHandle];
if (!handle3) {
const rep = e[symbolRscRep] || ++captureCnt2;
captureTable2.set(rep, e);
handle3 = rscTableCreateOwn(handleTable2, rep);
}
dataView(memory0).setInt32(arg1 + 4, handle3, true);
break;
}
case 'err': {
const e = variant5.val;
dataView(memory0).setInt8(arg1 + 0, 1, true);
var val4 = e;
let enum4;
switch (val4) {
case 'access': {
enum4 = 0;
break;
}
case 'would-block': {
enum4 = 1;
break;
}
case 'already': {
enum4 = 2;
break;
}
case 'bad-descriptor': {
enum4 = 3;
break;
}
case 'busy': {
enum4 = 4;
break;
}
case 'deadlock': {
enum4 = 5;
break;
}
case 'quota': {
enum4 = 6;
break;
}
case 'exist': {
enum4 = 7;
break;
}
case 'file-too-large': {
enum4 = 8;
break;
}
case 'illegal-byte-sequence': {
enum4 = 9;
break;
}
case 'in-progress': {
enum4 = 10;
break;
}
case 'interrupted': {
enum4 = 11;
break;
}
case 'invalid': {
enum4 = 12;
break;
}
case 'io': {
enum4 = 13;
break;
}
case 'is-directory': {
enum4 = 14;
break;
}
case 'loop': {
enum4 = 15;
break;
}
case 'too-many-links': {
enum4 = 16;
break;
}
case 'message-size': {
enum4 = 17;
break;
}
case 'name-too-long': {
enum4 = 18;
break;
}
case 'no-device': {
enum4 = 19;
break;
}
case 'no-entry': {
enum4 = 20;
break;
}
case 'no-lock': {
enum4 = 21;
break;
}
case 'insufficient-memory': {
enum4 = 22;
break;
}
case 'insufficient-space': {
enum4 = 23;
break;
}
case 'not-directory': {
enum4 = 24;
break;
}
case 'not-empty': {
enum4 = 25;
break;
}
case 'not-recoverable': {
enum4 = 26;
break;
}
case 'unsupported': {
enum4 = 27;
break;
}
case 'no-tty': {
enum4 = 28;
break;
}
case 'no-such-device': {
enum4 = 29;
break;
}
case 'overflow': {
enum4 = 30;
break;
}
case 'not-permitted': {
enum4 = 31;
break;
}
case 'pipe': {
enum4 = 32;
break;
}
case 'read-only': {
enum4 = 33;
break;
}
case 'invalid-seek': {
enum4 = 34;
break;
}
case 'text-file-busy': {
enum4 = 35;
break;
}
case 'cross-device': {
enum4 = 36;
break;
}
default: {
if ((e) instanceof Error) {
console.error(e);
}
throw new TypeError(`"${val4}" is not one of the cases of error-code`);
}
}
dataView(memory0).setInt8(arg1 + 4, enum4, true);
break;
}
default: {
throw new TypeError('invalid variant specified for result');
}
}
}
const handleTable5 = [T_FLAG, 0];
const captureTable5= new Map();
let captureCnt5 = 0;
handleTables[5] = handleTable5;
function trampoline19(arg0, arg1) {
var handle1 = arg0;
var rep2 = handleTable6[(handle1 << 1) + 1] & ~T_FLAG;
var rsc0 = captureTable6.get(rep2);
if (!rsc0) {
rsc0 = Object.create(Descriptor.prototype);
Object.defineProperty(rsc0, symbolRscHandle, { writable: true, value: handle1});
Object.defineProperty(rsc0, symbolRscRep, { writable: true, value: rep2});
}
curResourceBorrows.push(rsc0);
let ret;
try {
ret = { tag: 'ok', val: rsc0.readDirectory()};
} catch (e) {
ret = { tag: 'err', val: getErrorPayload(e) };
}
for (const rsc of curResourceBorrows) {
rsc[symbolRscHandle] = undefined;
}
curResourceBorrows = [];
var variant5 = ret;
switch (variant5.tag) {
case 'ok': {
const e = variant5.val;
dataView(memory0).setInt8(arg1 + 0, 0, true);
if (!(e instanceof DirectoryEntryStream)) {
throw new TypeError('Resource error: Not a valid "DirectoryEntryStream" resource.');
}
var handle3 = e[symbolRscHandle];
if (!handle3) {
const rep = e[symbolRscRep] || ++captureCnt5;
captureTable5.set(rep, e);
handle3 = rscTableCreateOwn(handleTable5, rep);
}
dataView(memory0).setInt32(arg1 + 4, handle3, true);
break;
}
case 'err': {
const e = variant5.val;
dataView(memory0).setInt8(arg1 + 0, 1, true);
var val4 = e;
let enum4;
switch (val4) {
case 'access': {
enum4 = 0;
break;
}
case 'would-block': {
enum4 = 1;
break;
}
case 'already': {
enum4 = 2;
break;
}
case 'bad-descriptor': {
enum4 = 3;
break;
}
case 'busy': {
enum4 = 4;
break;
}
case 'deadlock': {
enum4 = 5;
break;
}
case 'quota': {
enum4 = 6;
break;
}
case 'exist': {
enum4 = 7;
break;
}
case 'file-too-large': {
enum4 = 8;
break;
}
case 'illegal-byte-sequence': {
enum4 = 9;
break;
}
case 'in-progress': {
enum4 = 10;
break;
}
case 'interrupted': {
enum4 = 11;
break;
}
case 'invalid': {
enum4 = 12;
break;
}
case 'io': {
enum4 = 13;
break;
}
case 'is-directory': {
enum4 = 14;
break;
}
case 'loop': {
enum4 = 15;
break;
}
case 'too-many-links': {
enum4 = 16;
break;
}
case 'message-size': {
enum4 = 17;
break;
}
case 'name-too-long': {
enum4 = 18;
break;
}
case 'no-device': {
enum4 = 19;
break;
}
case 'no-entry': {
enum4 = 20;
break;
}
case 'no-lock': {
enum4 = 21;
break;
}
case 'insufficient-memory': {
enum4 = 22;
break;
}
case 'insufficient-space': {
enum4 = 23;
break;
}
case 'not-directory': {
enum4 = 24;
break;
}
case 'not-empty': {
enum4 = 25;
break;
}
case 'not-recoverable': {
enum4 = 26;
break;
}
case 'unsupported': {
enum4 = 27;
break;
}
case 'no-tty': {
enum4 = 28;
break;
}
case 'no-such-device': {
enum4 = 29;
break;
}
case 'overflow': {
enum4 = 30;
break;
}
case 'not-permitted': {
enum4 = 31;
break;
}
case 'pipe': {
enum4 = 32;
break;
}
case 'read-only': {
enum4 = 33;
break;
}
case 'invalid-seek': {
enum4 = 34;
break;
}
case 'text-file-busy': {
enum4 = 35;
break;
}
case 'cross-device': {
enum4 = 36;
break;
}
default: {
if ((e) instanceof Error) {
console.error(e);
}
throw new TypeError(`"${val4}" is not one of the cases of error-code`);
}
}
dataView(memory0).setInt8(arg1 + 4, enum4, true);
break;
}
default: {
throw new TypeError('invalid variant specified for result');
}
}
}
function trampoline20(arg0, arg1) {
var handle1 = arg0;
var rep2 = handleTable6[(handle1 << 1) + 1] & ~T_FLAG;
var rsc0 = captureTable6.get(rep2);
if (!rsc0) {
rsc0 = Object.create(Descriptor.prototype);
Object.defineProperty(rsc0, symbolRscHandle, { writable: true, value: handle1});
Object.defineProperty(rsc0, symbolRscRep, { writable: true, value: rep2});
}
curResourceBorrows.push(rsc0);
let ret;
try {
ret = { tag: 'ok', val: rsc0.stat()};
} catch (e) {
ret = { tag: 'err', val: getErrorPayload(e) };
}
for (const rsc of curResourceBorrows) {
rsc[symbolRscHandle] = undefined;
}
curResourceBorrows = [];
var variant12 = ret;
switch (variant12.tag) {
case 'ok': {
const e = variant12.val;
dataView(memory0).setInt8(arg1 + 0, 0, true);
var {type: v3_0, linkCount: v3_1, size: v3_2, dataAccessTimestamp: v3_3, dataModificationTimestamp: v3_4, statusChangeTimestamp: v3_5 } = e;
var val4 = v3_0;
let enum4;
switch (val4) {
case 'unknown': {
enum4 = 0;
break;
}
case 'block-device': {
enum4 = 1;
break;
}
case 'character-device': {
enum4 = 2;
break;
}
case 'directory': {
enum4 = 3;
break;
}
case 'fifo': {
enum4 = 4;
break;
}
case 'symbolic-link': {
enum4 = 5;
break;
}
case 'regular-file': {
enum4 = 6;
break;
}
case 'socket': {
enum4 = 7;
break;
}
default: {
if ((v3_0) instanceof Error) {
console.error(v3_0);
}
throw new TypeError(`"${val4}" is not one of the cases of descriptor-type`);
}
}
dataView(memory0).setInt8(arg1 + 8, enum4, true);
dataView(memory0).setBigInt64(arg1 + 16, toUint64(v3_1), true);
dataView(memory0).setBigInt64(arg1 + 24, toUint64(v3_2), true);
var variant6 = v3_3;
if (variant6 === null || variant6=== undefined) {
dataView(memory0).setInt8(arg1 + 32, 0, true);
} else {
const e = variant6;
dataView(memory0).setInt8(arg1 + 32, 1, true);
var {seconds: v5_0, nanoseconds: v5_1 } = e;
dataView(memory0).setBigInt64(arg1 + 40, toUint64(v5_0), true);
dataView(memory0).setInt32(arg1 + 48, toUint32(v5_1), true);
}
var variant8 = v3_4;
if (variant8 === null || variant8=== undefined) {
dataView(memory0).setInt8(arg1 + 56, 0, true);
} else {
const e = variant8;
dataView(memory0).setInt8(arg1 + 56, 1, true);
var {seconds: v7_0, nanoseconds: v7_1 } = e;
dataView(memory0).setBigInt64(arg1 + 64, toUint64(v7_0), true);
dataView(memory0).setInt32(arg1 + 72, toUint32(v7_1), true);
}
var variant10 = v3_5;
if (variant10 === null || variant10=== undefined) {
dataView(memory0).setInt8(arg1 + 80, 0, true);
} else {
const e = variant10;
dataView(memory0).setInt8(arg1 + 80, 1, true);
var {seconds: v9_0, nanoseconds: v9_1 } = e;
dataView(memory0).setBigInt64(arg1 + 88, toUint64(v9_0), true);
dataView(memory0).setInt32(arg1 + 96, toUint32(v9_1), true);
}
break;
}
case 'err': {
const e = variant12.val;
dataView(memory0).setInt8(arg1 + 0, 1, true);
var val11 = e;
let enum11;
switch (val11) {
case 'access': {
enum11 = 0;
break;
}
case 'would-block': {
enum11 = 1;
break;
}
case 'already': {
enum11 = 2;
break;
}
case 'bad-descriptor': {
enum11 = 3;
break;
}
case 'busy': {
enum11 = 4;
break;
}
case 'deadlock': {
enum11 = 5;
break;
}
case 'quota': {
enum11 = 6;
break;
}
case 'exist': {
enum11 = 7;
break;
}
case 'file-too-large': {
enum11 = 8;
break;
}
case 'illegal-byte-sequence': {
enum11 = 9;
break;
}
case 'in-progress': {
enum11 = 10;
break;
}
case 'interrupted': {
enum11 = 11;
break;
}
case 'invalid': {
enum11 = 12;
break;
}
case 'io': {
enum11 = 13;
break;
}
case 'is-directory': {
enum11 = 14;
break;
}
case 'loop': {
enum11 = 15;
break;
}
case 'too-many-links': {
enum11 = 16;
break;
}
case 'message-size': {
enum11 = 17;
break;
}
case 'name-too-long': {
enum11 = 18;
break;
}
case 'no-device': {
enum11 = 19;
break;
}
case 'no-entry': {
enum11 = 20;
break;
}
case 'no-lock': {
enum11 = 21;
break;
}
case 'insufficient-memory': {
enum11 = 22;
break;
}
case 'insufficient-space': {
enum11 = 23;
break;
}
case 'not-directory': {
enum11 = 24;
break;
}
case 'not-empty': {
enum11 = 25;
break;
}
case 'not-recoverable': {
enum11 = 26;
break;
}
case 'unsupported': {
enum11 = 27;
break;
}
case 'no-tty': {
enum11 = 28;
break;
}
case 'no-such-device': {
enum11 = 29;
break;
}
case 'overflow': {
enum11 = 30;
break;
}
case 'not-permitted': {
enum11 = 31;
break;
}
case 'pipe': {
enum11 = 32;
break;
}
case 'read-only': {
enum11 = 33;
break;
}
case 'invalid-seek': {