universal-lambda-zig/src/script_harness.js

// 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;
};

// src/index.js