From 4e90d05a77d9086e21c51b1feb2482caf3d8e662 Mon Sep 17 00:00:00 2001 From: Emil Lerch Date: Tue, 17 Oct 2023 19:52:52 -0700 Subject: [PATCH] update index.js to the bundled version generated by wrangler --- src/index.js | 817 +++++++++++++++++++++++++++++++++++++++++++++++++-- 1 file changed, 794 insertions(+), 23 deletions(-) diff --git a/src/index.js b/src/index.js index 67115a9..f07b7d0 100644 --- a/src/index.js +++ b/src/index.js @@ -1,41 +1,812 @@ -import { WASI } from "@cloudflare/workers-wasi"; -import demoWasm from "./demo.wasm"; +// node_modules/@cloudflare/workers-wasi/dist/index.mjs +import wasm from "./c5f1acc97ad09df861eff9ef567c2186d4e38de3-memfs.wasm"; +var __accessCheck = (obj, member, msg) => { + if (!member.has(obj)) + throw TypeError("Cannot " + msg); +}; +var __privateGet = (obj, member, getter) => { + __accessCheck(obj, member, "read from private field"); + return getter ? getter.call(obj) : member.get(obj); +}; +var __privateAdd = (obj, member, value) => { + if (member.has(obj)) + throw TypeError("Cannot add the same private member more than once"); + member instanceof WeakSet ? member.add(obj) : member.set(obj, value); +}; +var __privateSet = (obj, member, value, setter) => { + __accessCheck(obj, member, "write to private field"); + setter ? setter.call(obj, value) : member.set(obj, value); + return value; +}; +var __privateMethod = (obj, member, method) => { + __accessCheck(obj, member, "access private method"); + return method; +}; +var Result; +(function(Result2) { + Result2[Result2["SUCCESS"] = 0] = "SUCCESS"; + Result2[Result2["EBADF"] = 8] = "EBADF"; + Result2[Result2["EINVAL"] = 28] = "EINVAL"; + Result2[Result2["ENOENT"] = 44] = "ENOENT"; + Result2[Result2["ENOSYS"] = 52] = "ENOSYS"; + Result2[Result2["ENOTSUP"] = 58] = "ENOTSUP"; +})(Result || (Result = {})); +var Clock; +(function(Clock2) { + Clock2[Clock2["REALTIME"] = 0] = "REALTIME"; + Clock2[Clock2["MONOTONIC"] = 1] = "MONOTONIC"; + Clock2[Clock2["PROCESS_CPUTIME_ID"] = 2] = "PROCESS_CPUTIME_ID"; + Clock2[Clock2["THREAD_CPUTIME_ID"] = 3] = "THREAD_CPUTIME_ID"; +})(Clock || (Clock = {})); +var iovViews = (view, iovs_ptr, iovs_len) => { + let result = Array(iovs_len); + for (let i = 0; i < iovs_len; i++) { + const bufferPtr = view.getUint32(iovs_ptr, true); + iovs_ptr += 4; + const bufferLen = view.getUint32(iovs_ptr, true); + iovs_ptr += 4; + result[i] = new Uint8Array(view.buffer, bufferPtr, bufferLen); + } + return result; +}; +var _instance; +var _hostMemory; +var _getInternalView; +var getInternalView_fn; +var _copyFrom; +var copyFrom_fn; +var MemFS = class { + constructor(preopens, fs) { + __privateAdd(this, _getInternalView); + __privateAdd(this, _copyFrom); + __privateAdd(this, _instance, void 0); + __privateAdd(this, _hostMemory, void 0); + __privateSet(this, _instance, new WebAssembly.Instance(wasm, { + internal: { + now_ms: () => Date.now(), + trace: (isError, addr, size) => { + const view = new Uint8Array(__privateMethod(this, _getInternalView, getInternalView_fn).call(this).buffer, addr, size); + const s = new TextDecoder().decode(view); + if (isError) { + throw new Error(s); + } else { + console.info(s); + } + }, + copy_out: (srcAddr, dstAddr, size) => { + const dst = new Uint8Array(__privateGet(this, _hostMemory).buffer, dstAddr, size); + const src = new Uint8Array(__privateMethod(this, _getInternalView, getInternalView_fn).call(this).buffer, srcAddr, size); + dst.set(src); + }, + copy_in: (srcAddr, dstAddr, size) => { + const src = new Uint8Array(__privateGet(this, _hostMemory).buffer, srcAddr, size); + const dst = new Uint8Array(__privateMethod(this, _getInternalView, getInternalView_fn).call(this).buffer, dstAddr, size); + dst.set(src); + } + }, + wasi_snapshot_preview1: { + proc_exit: (_) => { + }, + fd_seek: () => Result.ENOSYS, + fd_write: () => Result.ENOSYS, + fd_close: () => Result.ENOSYS + } + })); + this.exports = __privateGet(this, _instance).exports; + const start = __privateGet(this, _instance).exports._start; + start(); + const data = new TextEncoder().encode(JSON.stringify({ preopens, fs })); + const initialize_internal = __privateGet(this, _instance).exports.initialize_internal; + initialize_internal(__privateMethod(this, _copyFrom, copyFrom_fn).call(this, data), data.byteLength); + } + initialize(hostMemory) { + __privateSet(this, _hostMemory, hostMemory); + } +}; +_instance = /* @__PURE__ */ new WeakMap(); +_hostMemory = /* @__PURE__ */ new WeakMap(); +_getInternalView = /* @__PURE__ */ new WeakSet(); +getInternalView_fn = function() { + const memory = __privateGet(this, _instance).exports.memory; + return new DataView(memory.buffer); +}; +_copyFrom = /* @__PURE__ */ new WeakSet(); +copyFrom_fn = function(src) { + const dstAddr = __privateGet(this, _instance).exports.allocate(src.byteLength); + new Uint8Array(__privateMethod(this, _getInternalView, getInternalView_fn).call(this).buffer, dstAddr, src.byteLength).set(src); + return dstAddr; +}; +var DATA_ADDR = 16; +var DATA_START = DATA_ADDR + 8; +var DATA_END = 1024; +var WRAPPED_EXPORTS = /* @__PURE__ */ new WeakMap(); +var State = { + None: 0, + Unwinding: 1, + Rewinding: 2 +}; +function isPromise(obj) { + return !!obj && (typeof obj === "object" || typeof obj === "function") && typeof obj.then === "function"; +} +function proxyGet(obj, transform) { + return new Proxy(obj, { + get: (obj2, name) => transform(obj2[name]) + }); +} +var Asyncify = class { + constructor() { + this.value = void 0; + this.exports = null; + } + getState() { + return this.exports.asyncify_get_state(); + } + assertNoneState() { + let state = this.getState(); + if (state !== State.None) { + throw new Error(`Invalid async state ${state}, expected 0.`); + } + } + wrapImportFn(fn) { + return (...args) => { + if (this.getState() === State.Rewinding) { + this.exports.asyncify_stop_rewind(); + return this.value; + } + this.assertNoneState(); + let value = fn(...args); + if (!isPromise(value)) { + return value; + } + this.exports.asyncify_start_unwind(DATA_ADDR); + this.value = value; + }; + } + wrapModuleImports(module) { + return proxyGet(module, (value) => { + if (typeof value === "function") { + return this.wrapImportFn(value); + } + return value; + }); + } + wrapImports(imports) { + if (imports === void 0) + return; + return proxyGet(imports, (moduleImports = /* @__PURE__ */ Object.create(null)) => this.wrapModuleImports(moduleImports)); + } + wrapExportFn(fn) { + let newExport = WRAPPED_EXPORTS.get(fn); + if (newExport !== void 0) { + return newExport; + } + newExport = async (...args) => { + this.assertNoneState(); + let result = fn(...args); + while (this.getState() === State.Unwinding) { + this.exports.asyncify_stop_unwind(); + this.value = await this.value; + this.assertNoneState(); + this.exports.asyncify_start_rewind(DATA_ADDR); + result = fn(); + } + this.assertNoneState(); + return result; + }; + WRAPPED_EXPORTS.set(fn, newExport); + return newExport; + } + wrapExports(exports) { + let newExports = /* @__PURE__ */ Object.create(null); + for (let exportName in exports) { + let value = exports[exportName]; + if (typeof value === "function" && !exportName.startsWith("asyncify_")) { + value = this.wrapExportFn(value); + } + Object.defineProperty(newExports, exportName, { + enumerable: true, + value + }); + } + WRAPPED_EXPORTS.set(exports, newExports); + return newExports; + } + init(instance, imports) { + const { exports } = instance; + const memory = exports.memory || imports.env && imports.env.memory; + new Int32Array(memory.buffer, DATA_ADDR).set([DATA_START, DATA_END]); + this.exports = this.wrapExports(exports); + Object.setPrototypeOf(instance, Instance.prototype); + } +}; +var Instance = class extends WebAssembly.Instance { + constructor(module, imports) { + let state = new Asyncify(); + super(module, state.wrapImports(imports)); + state.init(this, imports); + } + get exports() { + return WRAPPED_EXPORTS.get(super.exports); + } +}; +Object.defineProperty(Instance.prototype, "exports", { enumerable: true }); +var DevNull = class { + writev(iovs) { + return iovs.map((iov) => iov.byteLength).reduce((prev, curr) => prev + curr); + } + readv(iovs) { + return 0; + } + close() { + } + async preRun() { + } + async postRun() { + } +}; +var ReadableStreamBase = class { + writev(iovs) { + throw new Error("Attempting to call write on a readable stream"); + } + close() { + } + async preRun() { + } + async postRun() { + } +}; +var _pending; +var _reader; +var AsyncReadableStreamAdapter = class extends ReadableStreamBase { + constructor(reader) { + super(); + __privateAdd(this, _pending, new Uint8Array()); + __privateAdd(this, _reader, void 0); + __privateSet(this, _reader, reader); + } + async readv(iovs) { + let read = 0; + for (let iov of iovs) { + while (iov.byteLength > 0) { + if (__privateGet(this, _pending).byteLength === 0) { + const result = await __privateGet(this, _reader).read(); + if (result.done) { + return read; + } + __privateSet(this, _pending, result.value); + } + const bytes = Math.min(iov.byteLength, __privateGet(this, _pending).byteLength); + iov.set(__privateGet(this, _pending).subarray(0, bytes)); + __privateSet(this, _pending, __privateGet(this, _pending).subarray(bytes)); + read += bytes; + iov = iov.subarray(bytes); + } + } + return read; + } +}; +_pending = /* @__PURE__ */ new WeakMap(); +_reader = /* @__PURE__ */ new WeakMap(); +var WritableStreamBase = class { + readv(iovs) { + throw new Error("Attempting to call read on a writable stream"); + } + close() { + } + async preRun() { + } + async postRun() { + } +}; +var _writer; +var AsyncWritableStreamAdapter = class extends WritableStreamBase { + constructor(writer) { + super(); + __privateAdd(this, _writer, void 0); + __privateSet(this, _writer, writer); + } + async writev(iovs) { + let written = 0; + for (const iov of iovs) { + if (iov.byteLength === 0) { + continue; + } + await __privateGet(this, _writer).write(iov); + written += iov.byteLength; + } + return written; + } + async close() { + await __privateGet(this, _writer).close(); + } +}; +_writer = /* @__PURE__ */ new WeakMap(); +var _writer2; +var _buffer; +var _bytesWritten; +var SyncWritableStreamAdapter = class extends WritableStreamBase { + constructor(writer) { + super(); + __privateAdd(this, _writer2, void 0); + __privateAdd(this, _buffer, new Uint8Array(4096)); + __privateAdd(this, _bytesWritten, 0); + __privateSet(this, _writer2, writer); + } + writev(iovs) { + let written = 0; + for (const iov of iovs) { + if (iov.byteLength === 0) { + continue; + } + const requiredCapacity = __privateGet(this, _bytesWritten) + iov.byteLength; + if (requiredCapacity > __privateGet(this, _buffer).byteLength) { + let desiredCapacity = __privateGet(this, _buffer).byteLength; + while (desiredCapacity < requiredCapacity) { + desiredCapacity *= 1.5; + } + const oldBuffer = __privateGet(this, _buffer); + __privateSet(this, _buffer, new Uint8Array(desiredCapacity)); + __privateGet(this, _buffer).set(oldBuffer); + } + __privateGet(this, _buffer).set(iov, __privateGet(this, _bytesWritten)); + written += iov.byteLength; + __privateSet(this, _bytesWritten, __privateGet(this, _bytesWritten) + iov.byteLength); + } + return written; + } + async postRun() { + const slice = __privateGet(this, _buffer).subarray(0, __privateGet(this, _bytesWritten)); + await __privateGet(this, _writer2).write(slice); + await __privateGet(this, _writer2).close(); + } +}; +_writer2 = /* @__PURE__ */ new WeakMap(); +_buffer = /* @__PURE__ */ new WeakMap(); +_bytesWritten = /* @__PURE__ */ new WeakMap(); +var _buffer2; +var _reader2; +var SyncReadableStreamAdapter = class extends ReadableStreamBase { + constructor(reader) { + super(); + __privateAdd(this, _buffer2, void 0); + __privateAdd(this, _reader2, void 0); + __privateSet(this, _reader2, reader); + } + readv(iovs) { + let read = 0; + for (const iov of iovs) { + const bytes = Math.min(iov.byteLength, __privateGet(this, _buffer2).byteLength); + if (bytes <= 0) { + break; + } + iov.set(__privateGet(this, _buffer2).subarray(0, bytes)); + __privateSet(this, _buffer2, __privateGet(this, _buffer2).subarray(bytes)); + read += bytes; + } + return read; + } + async preRun() { + const pending = []; + let length = 0; + for (; ; ) { + const result2 = await __privateGet(this, _reader2).read(); + if (result2.done) { + break; + } + const data = result2.value; + pending.push(data); + length += data.length; + } + let result = new Uint8Array(length); + let offset = 0; + pending.forEach((item) => { + result.set(item, offset); + offset += item.length; + }); + __privateSet(this, _buffer2, result); + } +}; +_buffer2 = /* @__PURE__ */ new WeakMap(); +_reader2 = /* @__PURE__ */ new WeakMap(); +var fromReadableStream = (stream, supportsAsync) => { + if (!stream) { + return new DevNull(); + } + if (supportsAsync) { + return new AsyncReadableStreamAdapter(stream.getReader()); + } + return new SyncReadableStreamAdapter(stream.getReader()); +}; +var fromWritableStream = (stream, supportsAsync) => { + if (!stream) { + return new DevNull(); + } + if (supportsAsync) { + return new AsyncWritableStreamAdapter(stream.getWriter()); + } + return new SyncWritableStreamAdapter(stream.getWriter()); +}; +var ProcessExit = class extends Error { + constructor(code) { + super(`proc_exit=${code}`); + this.code = code; + Object.setPrototypeOf(this, ProcessExit.prototype); + } +}; +var _args; +var _env; +var _memory; +var _preopens; +var _returnOnExit; +var _streams; +var _memfs; +var _state; +var _asyncify; +var _view; +var view_fn; +var _fillValues; +var fillValues_fn; +var _fillSizes; +var fillSizes_fn; +var _args_get; +var args_get_fn; +var _args_sizes_get; +var args_sizes_get_fn; +var _clock_res_get; +var clock_res_get_fn; +var _clock_time_get; +var clock_time_get_fn; +var _environ_get; +var environ_get_fn; +var _environ_sizes_get; +var environ_sizes_get_fn; +var _fd_read; +var fd_read_fn; +var _fd_write; +var fd_write_fn; +var _poll_oneoff; +var poll_oneoff_fn; +var _proc_exit; +var proc_exit_fn; +var _proc_raise; +var proc_raise_fn; +var _random_get; +var random_get_fn; +var _sched_yield; +var sched_yield_fn; +var _sock_recv; +var sock_recv_fn; +var _sock_send; +var sock_send_fn; +var _sock_shutdown; +var sock_shutdown_fn; +var WASI = class { + constructor(options) { + __privateAdd(this, _view); + __privateAdd(this, _fillValues); + __privateAdd(this, _fillSizes); + __privateAdd(this, _args_get); + __privateAdd(this, _args_sizes_get); + __privateAdd(this, _clock_res_get); + __privateAdd(this, _clock_time_get); + __privateAdd(this, _environ_get); + __privateAdd(this, _environ_sizes_get); + __privateAdd(this, _fd_read); + __privateAdd(this, _fd_write); + __privateAdd(this, _poll_oneoff); + __privateAdd(this, _proc_exit); + __privateAdd(this, _proc_raise); + __privateAdd(this, _random_get); + __privateAdd(this, _sched_yield); + __privateAdd(this, _sock_recv); + __privateAdd(this, _sock_send); + __privateAdd(this, _sock_shutdown); + __privateAdd(this, _args, void 0); + __privateAdd(this, _env, void 0); + __privateAdd(this, _memory, void 0); + __privateAdd(this, _preopens, void 0); + __privateAdd(this, _returnOnExit, void 0); + __privateAdd(this, _streams, void 0); + __privateAdd(this, _memfs, void 0); + __privateAdd(this, _state, new Asyncify()); + __privateAdd(this, _asyncify, void 0); + __privateSet(this, _args, options?.args ?? []); + const env = options?.env ?? {}; + __privateSet(this, _env, Object.keys(env).map((key) => { + return `${key}=${env[key]}`; + })); + __privateSet(this, _returnOnExit, options?.returnOnExit ?? false); + __privateSet(this, _preopens, options?.preopens ?? []); + __privateSet(this, _asyncify, options?.streamStdio ?? false); + __privateSet(this, _streams, [ + fromReadableStream(options?.stdin, __privateGet(this, _asyncify)), + fromWritableStream(options?.stdout, __privateGet(this, _asyncify)), + fromWritableStream(options?.stderr, __privateGet(this, _asyncify)) + ]); + __privateSet(this, _memfs, new MemFS(__privateGet(this, _preopens), options?.fs ?? {})); + } + async start(instance) { + __privateSet(this, _memory, instance.exports.memory); + __privateGet(this, _memfs).initialize(__privateGet(this, _memory)); + try { + if (__privateGet(this, _asyncify)) { + if (!instance.exports.asyncify_get_state) { + throw new Error("streamStdio is requested but the module is missing 'Asyncify' exports, see https://github.com/GoogleChromeLabs/asyncify"); + } + __privateGet(this, _state).init(instance); + } + await Promise.all(__privateGet(this, _streams).map((s) => s.preRun())); + if (__privateGet(this, _asyncify)) { + await __privateGet(this, _state).exports._start(); + } else { + const entrypoint = instance.exports._start; + entrypoint(); + } + } catch (e) { + if (!__privateGet(this, _returnOnExit)) { + throw e; + } + if (e.message === "unreachable") { + return 134; + } else if (e instanceof ProcessExit) { + return e.code; + } else { + throw e; + } + } finally { + await Promise.all(__privateGet(this, _streams).map((s) => s.close())); + await Promise.all(__privateGet(this, _streams).map((s) => s.postRun())); + } + return void 0; + } + get wasiImport() { + const wrap = (f, self = this) => { + const bound = f.bind(self); + if (__privateGet(this, _asyncify)) { + return __privateGet(this, _state).wrapImportFn(bound); + } + return bound; + }; + return { + args_get: wrap(__privateMethod(this, _args_get, args_get_fn)), + args_sizes_get: wrap(__privateMethod(this, _args_sizes_get, args_sizes_get_fn)), + clock_res_get: wrap(__privateMethod(this, _clock_res_get, clock_res_get_fn)), + clock_time_get: wrap(__privateMethod(this, _clock_time_get, clock_time_get_fn)), + environ_get: wrap(__privateMethod(this, _environ_get, environ_get_fn)), + environ_sizes_get: wrap(__privateMethod(this, _environ_sizes_get, environ_sizes_get_fn)), + fd_advise: wrap(__privateGet(this, _memfs).exports.fd_advise), + fd_allocate: wrap(__privateGet(this, _memfs).exports.fd_allocate), + fd_close: wrap(__privateGet(this, _memfs).exports.fd_close), + fd_datasync: wrap(__privateGet(this, _memfs).exports.fd_datasync), + fd_fdstat_get: wrap(__privateGet(this, _memfs).exports.fd_fdstat_get), + fd_fdstat_set_flags: wrap(__privateGet(this, _memfs).exports.fd_fdstat_set_flags), + fd_fdstat_set_rights: wrap(__privateGet(this, _memfs).exports.fd_fdstat_set_rights), + fd_filestat_get: wrap(__privateGet(this, _memfs).exports.fd_filestat_get), + fd_filestat_set_size: wrap(__privateGet(this, _memfs).exports.fd_filestat_set_size), + fd_filestat_set_times: wrap(__privateGet(this, _memfs).exports.fd_filestat_set_times), + fd_pread: wrap(__privateGet(this, _memfs).exports.fd_pread), + fd_prestat_dir_name: wrap(__privateGet(this, _memfs).exports.fd_prestat_dir_name), + fd_prestat_get: wrap(__privateGet(this, _memfs).exports.fd_prestat_get), + fd_pwrite: wrap(__privateGet(this, _memfs).exports.fd_pwrite), + fd_read: wrap(__privateMethod(this, _fd_read, fd_read_fn)), + fd_readdir: wrap(__privateGet(this, _memfs).exports.fd_readdir), + fd_renumber: wrap(__privateGet(this, _memfs).exports.fd_renumber), + fd_seek: wrap(__privateGet(this, _memfs).exports.fd_seek), + fd_sync: wrap(__privateGet(this, _memfs).exports.fd_sync), + fd_tell: wrap(__privateGet(this, _memfs).exports.fd_tell), + fd_write: wrap(__privateMethod(this, _fd_write, fd_write_fn)), + path_create_directory: wrap(__privateGet(this, _memfs).exports.path_create_directory), + path_filestat_get: wrap(__privateGet(this, _memfs).exports.path_filestat_get), + path_filestat_set_times: wrap(__privateGet(this, _memfs).exports.path_filestat_set_times), + path_link: wrap(__privateGet(this, _memfs).exports.path_link), + path_open: wrap(__privateGet(this, _memfs).exports.path_open), + path_readlink: wrap(__privateGet(this, _memfs).exports.path_readlink), + path_remove_directory: wrap(__privateGet(this, _memfs).exports.path_remove_directory), + path_rename: wrap(__privateGet(this, _memfs).exports.path_rename), + path_symlink: wrap(__privateGet(this, _memfs).exports.path_symlink), + path_unlink_file: wrap(__privateGet(this, _memfs).exports.path_unlink_file), + poll_oneoff: wrap(__privateMethod(this, _poll_oneoff, poll_oneoff_fn)), + proc_exit: wrap(__privateMethod(this, _proc_exit, proc_exit_fn)), + proc_raise: wrap(__privateMethod(this, _proc_raise, proc_raise_fn)), + random_get: wrap(__privateMethod(this, _random_get, random_get_fn)), + sched_yield: wrap(__privateMethod(this, _sched_yield, sched_yield_fn)), + sock_recv: wrap(__privateMethod(this, _sock_recv, sock_recv_fn)), + sock_send: wrap(__privateMethod(this, _sock_send, sock_send_fn)), + sock_shutdown: wrap(__privateMethod(this, _sock_shutdown, sock_shutdown_fn)) + }; + } +}; +_args = /* @__PURE__ */ new WeakMap(); +_env = /* @__PURE__ */ new WeakMap(); +_memory = /* @__PURE__ */ new WeakMap(); +_preopens = /* @__PURE__ */ new WeakMap(); +_returnOnExit = /* @__PURE__ */ new WeakMap(); +_streams = /* @__PURE__ */ new WeakMap(); +_memfs = /* @__PURE__ */ new WeakMap(); +_state = /* @__PURE__ */ new WeakMap(); +_asyncify = /* @__PURE__ */ new WeakMap(); +_view = /* @__PURE__ */ new WeakSet(); +view_fn = function() { + if (!__privateGet(this, _memory)) { + throw new Error("this.memory not set"); + } + return new DataView(__privateGet(this, _memory).buffer); +}; +_fillValues = /* @__PURE__ */ new WeakSet(); +fillValues_fn = function(values, iter_ptr_ptr, buf_ptr) { + const encoder = new TextEncoder(); + const buffer = new Uint8Array(__privateGet(this, _memory).buffer); + const view = __privateMethod(this, _view, view_fn).call(this); + for (const value of values) { + view.setUint32(iter_ptr_ptr, buf_ptr, true); + iter_ptr_ptr += 4; + const data = encoder.encode(`${value}\0`); + buffer.set(data, buf_ptr); + buf_ptr += data.length; + } + return Result.SUCCESS; +}; +_fillSizes = /* @__PURE__ */ new WeakSet(); +fillSizes_fn = function(values, count_ptr, buffer_size_ptr) { + const view = __privateMethod(this, _view, view_fn).call(this); + const encoder = new TextEncoder(); + const len = values.reduce((acc, value) => { + return acc + encoder.encode(`${value}\0`).length; + }, 0); + view.setUint32(count_ptr, values.length, true); + view.setUint32(buffer_size_ptr, len, true); + return Result.SUCCESS; +}; +_args_get = /* @__PURE__ */ new WeakSet(); +args_get_fn = function(argv_ptr_ptr, argv_buf_ptr) { + return __privateMethod(this, _fillValues, fillValues_fn).call(this, __privateGet(this, _args), argv_ptr_ptr, argv_buf_ptr); +}; +_args_sizes_get = /* @__PURE__ */ new WeakSet(); +args_sizes_get_fn = function(argc_ptr, argv_buf_size_ptr) { + return __privateMethod(this, _fillSizes, fillSizes_fn).call(this, __privateGet(this, _args), argc_ptr, argv_buf_size_ptr); +}; +_clock_res_get = /* @__PURE__ */ new WeakSet(); +clock_res_get_fn = function(id, retptr0) { + switch (id) { + case Clock.REALTIME: + case Clock.MONOTONIC: + case Clock.PROCESS_CPUTIME_ID: + case Clock.THREAD_CPUTIME_ID: { + const view = __privateMethod(this, _view, view_fn).call(this); + view.setBigUint64(retptr0, BigInt(1e6), true); + return Result.SUCCESS; + } + } + return Result.EINVAL; +}; +_clock_time_get = /* @__PURE__ */ new WeakSet(); +clock_time_get_fn = function(id, precision, retptr0) { + switch (id) { + case Clock.REALTIME: + case Clock.MONOTONIC: + case Clock.PROCESS_CPUTIME_ID: + case Clock.THREAD_CPUTIME_ID: { + const view = __privateMethod(this, _view, view_fn).call(this); + view.setBigUint64(retptr0, BigInt(Date.now()) * BigInt(1e6), true); + return Result.SUCCESS; + } + } + return Result.EINVAL; +}; +_environ_get = /* @__PURE__ */ new WeakSet(); +environ_get_fn = function(env_ptr_ptr, env_buf_ptr) { + return __privateMethod(this, _fillValues, fillValues_fn).call(this, __privateGet(this, _env), env_ptr_ptr, env_buf_ptr); +}; +_environ_sizes_get = /* @__PURE__ */ new WeakSet(); +environ_sizes_get_fn = function(env_ptr, env_buf_size_ptr) { + return __privateMethod(this, _fillSizes, fillSizes_fn).call(this, __privateGet(this, _env), env_ptr, env_buf_size_ptr); +}; +_fd_read = /* @__PURE__ */ new WeakSet(); +fd_read_fn = function(fd, iovs_ptr, iovs_len, retptr0) { + if (fd < 3) { + const desc = __privateGet(this, _streams)[fd]; + const view = __privateMethod(this, _view, view_fn).call(this); + const iovs = iovViews(view, iovs_ptr, iovs_len); + const result = desc.readv(iovs); + if (typeof result === "number") { + view.setUint32(retptr0, result, true); + return Result.SUCCESS; + } + const promise = result; + return promise.then((read) => { + view.setUint32(retptr0, read, true); + return Result.SUCCESS; + }); + } + return __privateGet(this, _memfs).exports.fd_read(fd, iovs_ptr, iovs_len, retptr0); +}; +_fd_write = /* @__PURE__ */ new WeakSet(); +fd_write_fn = function(fd, ciovs_ptr, ciovs_len, retptr0) { + if (fd < 3) { + const desc = __privateGet(this, _streams)[fd]; + const view = __privateMethod(this, _view, view_fn).call(this); + const iovs = iovViews(view, ciovs_ptr, ciovs_len); + const result = desc.writev(iovs); + if (typeof result === "number") { + view.setUint32(retptr0, result, true); + return Result.SUCCESS; + } + let promise = result; + return promise.then((written) => { + view.setUint32(retptr0, written, true); + return Result.SUCCESS; + }); + } + return __privateGet(this, _memfs).exports.fd_write(fd, ciovs_ptr, ciovs_len, retptr0); +}; +_poll_oneoff = /* @__PURE__ */ new WeakSet(); +poll_oneoff_fn = function(in_ptr, out_ptr, nsubscriptions, retptr0) { + return Result.ENOSYS; +}; +_proc_exit = /* @__PURE__ */ new WeakSet(); +proc_exit_fn = function(code) { + throw new ProcessExit(code); +}; +_proc_raise = /* @__PURE__ */ new WeakSet(); +proc_raise_fn = function(signal) { + return Result.ENOSYS; +}; +_random_get = /* @__PURE__ */ new WeakSet(); +random_get_fn = function(buffer_ptr, buffer_len) { + const buffer = new Uint8Array(__privateGet(this, _memory).buffer, buffer_ptr, buffer_len); + crypto.getRandomValues(buffer); + return Result.SUCCESS; +}; +_sched_yield = /* @__PURE__ */ new WeakSet(); +sched_yield_fn = function() { + return Result.SUCCESS; +}; +_sock_recv = /* @__PURE__ */ new WeakSet(); +sock_recv_fn = function(fd, ri_data_ptr, ri_data_len, ri_flags, retptr0, retptr1) { + return Result.ENOSYS; +}; +_sock_send = /* @__PURE__ */ new WeakSet(); +sock_send_fn = function(fd, si_data_ptr, si_data_len, si_flags, retptr0) { + return Result.ENOSYS; +}; +_sock_shutdown = /* @__PURE__ */ new WeakSet(); +sock_shutdown_fn = function(fd, how) { + return Result.ENOSYS; +}; -export default { - async fetch(request, _env, ctx) { - // Creates a TransformStream we can use to pipe our stdout to our response body. +// src/index.js +import demoWasm from "./24526702f6c3ed7fb02b15125f614dd38804525f-demo.wasm"; +var src_default = { + async fetch(request, _env2, ctx) { const stdout = new TransformStream(); console.log(request); - console.log(_env); + console.log(_env2); console.log(ctx); - - // Get our headers into environment variables (should we prefix this?) let env = {}; request.headers.forEach((value, key) => { env[key] = value; }); const wasi = new WASI({ args: [ - './demo.wasm', // In a CLI, the first arg is the name of the exe - '--url=' + request.url, // this contains the target but is the full url, so we will use a different arg for this - '--method=' + request.method, - '-request="' + JSON.stringify(request) + '"', + "./demo.wasm", + // In a CLI, the first arg is the name of the exe + "--url=" + request.url, + // this contains the target but is the full url, so we will use a different arg for this + "--method=" + request.method, + '-request="' + JSON.stringify(request) + '"' ], - env: env, + env, stdin: request.body, - stdout: stdout.writable, + stdout: stdout.writable }); - - // Instantiate our WASM with our demo module and our configured WASI import. const instance = new WebAssembly.Instance(demoWasm, { - wasi_snapshot_preview1: wasi.wasiImport, + wasi_snapshot_preview1: wasi.wasiImport }); - - // Keep our worker alive until the WASM has finished executing. ctx.waitUntil(wasi.start(instance)); - - // Finally, let's reply with the WASM's output. return new Response(stdout.readable); - }, + } }; - +export { + src_default as default +}; +//# sourceMappingURL=index.js.map