@corpus-core/colibri-tor 1.1.22

package/node_modules/tor-js/dist/entryPoints/wasm-file/singleton.js

@@ -0,0 +1,2187 @@
+var __defProp = Object.defineProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+
+// src/polyfills.ts
+Symbol.dispose ??= /* @__PURE__ */ Symbol("Symbol.dispose");
+
+// ../pkg/tor_js.js
+var IntoUnderlyingByteSource = class {
+  __destroy_into_raw() {
+    const ptr = this.__wbg_ptr;
+    this.__wbg_ptr = 0;
+    IntoUnderlyingByteSourceFinalization.unregister(this);
+    return ptr;
+  }
+  free() {
+    const ptr = this.__destroy_into_raw();
+    wasm.__wbg_intounderlyingbytesource_free(ptr, 0);
+  }
+  /**
+   * @returns {number}
+   */
+  get autoAllocateChunkSize() {
+    const ret = wasm.intounderlyingbytesource_autoAllocateChunkSize(this.__wbg_ptr);
+    return ret >>> 0;
+  }
+  cancel() {
+    const ptr = this.__destroy_into_raw();
+    wasm.intounderlyingbytesource_cancel(ptr);
+  }
+  /**
+   * @param {ReadableByteStreamController} controller
+   * @returns {Promise<any>}
+   */
+  pull(controller) {
+    const ret = wasm.intounderlyingbytesource_pull(this.__wbg_ptr, controller);
+    return ret;
+  }
+  /**
+   * @param {ReadableByteStreamController} controller
+   */
+  start(controller) {
+    wasm.intounderlyingbytesource_start(this.__wbg_ptr, controller);
+  }
+  /**
+   * @returns {ReadableStreamType}
+   */
+  get type() {
+    const ret = wasm.intounderlyingbytesource_type(this.__wbg_ptr);
+    return __wbindgen_enum_ReadableStreamType[ret];
+  }
+};
+if (Symbol.dispose) IntoUnderlyingByteSource.prototype[Symbol.dispose] = IntoUnderlyingByteSource.prototype.free;
+var IntoUnderlyingSink = class {
+  __destroy_into_raw() {
+    const ptr = this.__wbg_ptr;
+    this.__wbg_ptr = 0;
+    IntoUnderlyingSinkFinalization.unregister(this);
+    return ptr;
+  }
+  free() {
+    const ptr = this.__destroy_into_raw();
+    wasm.__wbg_intounderlyingsink_free(ptr, 0);
+  }
+  /**
+   * @param {any} reason
+   * @returns {Promise<any>}
+   */
+  abort(reason) {
+    const ptr = this.__destroy_into_raw();
+    const ret = wasm.intounderlyingsink_abort(ptr, reason);
+    return ret;
+  }
+  /**
+   * @returns {Promise<any>}
+   */
+  close() {
+    const ptr = this.__destroy_into_raw();
+    const ret = wasm.intounderlyingsink_close(ptr);
+    return ret;
+  }
+  /**
+   * @param {any} chunk
+   * @returns {Promise<any>}
+   */
+  write(chunk) {
+    const ret = wasm.intounderlyingsink_write(this.__wbg_ptr, chunk);
+    return ret;
+  }
+};
+if (Symbol.dispose) IntoUnderlyingSink.prototype[Symbol.dispose] = IntoUnderlyingSink.prototype.free;
+var IntoUnderlyingSource = class _IntoUnderlyingSource {
+  static __wrap(ptr) {
+    ptr = ptr >>> 0;
+    const obj = Object.create(_IntoUnderlyingSource.prototype);
+    obj.__wbg_ptr = ptr;
+    IntoUnderlyingSourceFinalization.register(obj, obj.__wbg_ptr, obj);
+    return obj;
+  }
+  __destroy_into_raw() {
+    const ptr = this.__wbg_ptr;
+    this.__wbg_ptr = 0;
+    IntoUnderlyingSourceFinalization.unregister(this);
+    return ptr;
+  }
+  free() {
+    const ptr = this.__destroy_into_raw();
+    wasm.__wbg_intounderlyingsource_free(ptr, 0);
+  }
+  cancel() {
+    const ptr = this.__destroy_into_raw();
+    wasm.intounderlyingsource_cancel(ptr);
+  }
+  /**
+   * @param {ReadableStreamDefaultController} controller
+   * @returns {Promise<any>}
+   */
+  pull(controller) {
+    const ret = wasm.intounderlyingsource_pull(this.__wbg_ptr, controller);
+    return ret;
+  }
+};
+if (Symbol.dispose) IntoUnderlyingSource.prototype[Symbol.dispose] = IntoUnderlyingSource.prototype.free;
+var TorClient = class _TorClient {
+  static __wrap(ptr) {
+    ptr = ptr >>> 0;
+    const obj = Object.create(_TorClient.prototype);
+    obj.__wbg_ptr = ptr;
+    TorClientFinalization.register(obj, obj.__wbg_ptr, obj);
+    return obj;
+  }
+  __destroy_into_raw() {
+    const ptr = this.__wbg_ptr;
+    this.__wbg_ptr = 0;
+    TorClientFinalization.unregister(this);
+    return ptr;
+  }
+  free() {
+    const ptr = this.__destroy_into_raw();
+    wasm.__wbg_torclient_free(ptr, 0);
+  }
+  /**
+   * Close the TorClient and release resources
+   * @returns {Promise<any>}
+   */
+  close() {
+    const ret = wasm.torclient_close(this.__wbg_ptr);
+    return ret;
+  }
+  /**
+   * Create a new TorClient with the given options.
+   *
+   * This is an async operation that returns a Promise.
+   * The client will bootstrap and establish a connection to the Tor network.
+   *
+   * Usage from JS: `const client = await TorClient.create(options);`
+   * @param {TorClientOptions} options
+   * @returns {Promise<any>}
+   */
+  static create(options) {
+    _assertClass(options, TorClientOptions);
+    var ptr0 = options.__destroy_into_raw();
+    const ret = wasm.torclient_create(ptr0);
+    return ret;
+  }
+  /**
+   * Make an HTTP fetch request through Tor
+   *
+   * Returns a Promise that resolves to a standard browser `Response` object
+   * as soon as response headers are received. The body is a `ReadableStream`
+   * that reads from the Tor circuit on demand.
+   * @param {string} url
+   * @param {any} init
+   * @returns {Promise<any>}
+   */
+  fetch(url, init2) {
+    const ptr0 = passStringToWasm0(url, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
+    const len0 = WASM_VECTOR_LEN;
+    const ret = wasm.torclient_fetch(this.__wbg_ptr, ptr0, len0, init2);
+    return ret;
+  }
+  /**
+   * Wait until the client is ready for traffic (connection usable + valid directory).
+   * @returns {Promise<any>}
+   */
+  ready() {
+    const ret = wasm.torclient_ready(this.__wbg_ptr);
+    return ret;
+  }
+};
+if (Symbol.dispose) TorClient.prototype[Symbol.dispose] = TorClient.prototype.free;
+var TorClientOptions = class _TorClientOptions {
+  static __wrap(ptr) {
+    ptr = ptr >>> 0;
+    const obj = Object.create(_TorClientOptions.prototype);
+    obj.__wbg_ptr = ptr;
+    TorClientOptionsFinalization.register(obj, obj.__wbg_ptr, obj);
+    return obj;
+  }
+  __destroy_into_raw() {
+    const ptr = this.__wbg_ptr;
+    this.__wbg_ptr = 0;
+    TorClientOptionsFinalization.unregister(this);
+    return ptr;
+  }
+  free() {
+    const ptr = this.__destroy_into_raw();
+    wasm.__wbg_torclientoptions_free(ptr, 0);
+  }
+  /**
+   * Create options with a connect function.
+   *
+   * The connect function receives a target address string (e.g. "198.51.100.1:9001")
+   * and must return a Promise resolving to a socket object with:
+   * - `send(data: Uint8Array)` — send binary data
+   * - `onmessage: ((data: Uint8Array) => void) | null` — receive callback
+   * - `onclose: (() => void) | null` — close notification
+   * - `close()` — close the socket
+   *
+   * The TS wrapper provides this automatically via the Gateway class.
+   * @param {Function} connect
+   */
+  constructor(connect) {
+    const ret = wasm.torclientoptions_new(connect);
+    this.__wbg_ptr = ret >>> 0;
+    TorClientOptionsFinalization.register(this, this.__wbg_ptr, this);
+    return this;
+  }
+  /**
+   * Set a callback that provides bootstrap.zip bytes for fast directory pre-population.
+   *
+   * The callback should be `() => Promise<Uint8Array>` returning the uncompressed
+   * bootstrap.zip bytes (from a tor-js-gateway server).
+   *
+   * When set and storage has no cached consensus, the zip is parsed and the
+   * directory cache is pre-populated before bootstrap begins.
+   * @param {Function} callback
+   * @returns {TorClientOptions}
+   */
+  withFastBootstrap(callback) {
+    const ptr = this.__destroy_into_raw();
+    const ret = wasm.torclientoptions_withFastBootstrap(ptr, callback);
+    return _TorClientOptions.__wrap(ret);
+  }
+  /**
+   * Set a custom storage implementation for persistent state.
+   *
+   * When set, the Tor client will persist guard selection and other state
+   * to this storage, allowing faster reconnection across page reloads.
+   *
+   * If not set, in-memory storage is used (state lost on page reload).
+   *
+   * # Arguments
+   * * `storage` - A JavaScript object implementing the TorStorage interface
+   * @param {TorStorage} storage
+   * @returns {TorClientOptions}
+   */
+  withStorage(storage) {
+    const ptr = this.__destroy_into_raw();
+    const ret = wasm.torclientoptions_withStorage(ptr, storage);
+    return _TorClientOptions.__wrap(ret);
+  }
+};
+if (Symbol.dispose) TorClientOptions.prototype[Symbol.dispose] = TorClientOptions.prototype.free;
+function init(log_level) {
+  var ptr0 = isLikeNone(log_level) ? 0 : passStringToWasm0(log_level, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
+  var len0 = WASM_VECTOR_LEN;
+  const ret = wasm.init(ptr0, len0);
+  if (ret[1]) {
+    throw takeFromExternrefTable0(ret[0]);
+  }
+}
+function setLogCallback(callback) {
+  wasm.setLogCallback(callback);
+}
+function setLogLevel(level) {
+  const ptr0 = passStringToWasm0(level, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
+  const len0 = WASM_VECTOR_LEN;
+  const ret = wasm.setLogLevel(ptr0, len0);
+  if (ret[1]) {
+    throw takeFromExternrefTable0(ret[0]);
+  }
+}
+function __wbg_get_imports() {
+  const import0 = {
+    __proto__: null,
+    __wbg_Error_83742b46f01ce22d: function(arg0, arg1) {
+      const ret = Error(getStringFromWasm0(arg0, arg1));
+      return ret;
+    },
+    __wbg_String_8564e559799eccda: function(arg0, arg1) {
+      const ret = String(arg1);
+      const ptr1 = passStringToWasm0(ret, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
+      const len1 = WASM_VECTOR_LEN;
+      getDataViewMemory0().setInt32(arg0 + 4 * 1, len1, true);
+      getDataViewMemory0().setInt32(arg0 + 4 * 0, ptr1, true);
+    },
+    __wbg___wbindgen_boolean_get_c0f3f60bac5a78d1: function(arg0) {
+      const v = arg0;
+      const ret = typeof v === "boolean" ? v : void 0;
+      return isLikeNone(ret) ? 16777215 : ret ? 1 : 0;
+    },
+    __wbg___wbindgen_debug_string_5398f5bb970e0daa: function(arg0, arg1) {
+      const ret = debugString(arg1);
+      const ptr1 = passStringToWasm0(ret, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
+      const len1 = WASM_VECTOR_LEN;
+      getDataViewMemory0().setInt32(arg0 + 4 * 1, len1, true);
+      getDataViewMemory0().setInt32(arg0 + 4 * 0, ptr1, true);
+    },
+    __wbg___wbindgen_in_41dbb8413020e076: function(arg0, arg1) {
+      const ret = arg0 in arg1;
+      return ret;
+    },
+    __wbg___wbindgen_is_function_3c846841762788c1: function(arg0) {
+      const ret = typeof arg0 === "function";
+      return ret;
+    },
+    __wbg___wbindgen_is_null_0b605fc6b167c56f: function(arg0) {
+      const ret = arg0 === null;
+      return ret;
+    },
+    __wbg___wbindgen_is_object_781bc9f159099513: function(arg0) {
+      const val = arg0;
+      const ret = typeof val === "object" && val !== null;
+      return ret;
+    },
+    __wbg___wbindgen_is_string_7ef6b97b02428fae: function(arg0) {
+      const ret = typeof arg0 === "string";
+      return ret;
+    },
+    __wbg___wbindgen_is_undefined_52709e72fb9f179c: function(arg0) {
+      const ret = arg0 === void 0;
+      return ret;
+    },
+    __wbg___wbindgen_jsval_loose_eq_5bcc3bed3c69e72b: function(arg0, arg1) {
+      const ret = arg0 == arg1;
+      return ret;
+    },
+    __wbg___wbindgen_number_get_34bb9d9dcfa21373: function(arg0, arg1) {
+      const obj = arg1;
+      const ret = typeof obj === "number" ? obj : void 0;
+      getDataViewMemory0().setFloat64(arg0 + 8 * 1, isLikeNone(ret) ? 0 : ret, true);
+      getDataViewMemory0().setInt32(arg0 + 4 * 0, !isLikeNone(ret), true);
+    },
+    __wbg___wbindgen_string_get_395e606bd0ee4427: function(arg0, arg1) {
+      const obj = arg1;
+      const ret = typeof obj === "string" ? obj : void 0;
+      var ptr1 = isLikeNone(ret) ? 0 : passStringToWasm0(ret, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
+      var len1 = WASM_VECTOR_LEN;
+      getDataViewMemory0().setInt32(arg0 + 4 * 1, len1, true);
+      getDataViewMemory0().setInt32(arg0 + 4 * 0, ptr1, true);
+    },
+    __wbg___wbindgen_throw_6ddd609b62940d55: function(arg0, arg1) {
+      throw new Error(getStringFromWasm0(arg0, arg1));
+    },
+    __wbg__wbg_cb_unref_6b5b6b8576d35cb1: function(arg0) {
+      arg0._wbg_cb_unref();
+    },
+    __wbg_aborted_4789bfb2963583fb: function(arg0) {
+      const ret = arg0.aborted;
+      return ret;
+    },
+    __wbg_all_91078ec14f01cdc8: function(arg0) {
+      const ret = Promise.all(arg0);
+      return ret;
+    },
+    __wbg_append_608dfb635ee8998f: function() {
+      return handleError(function(arg0, arg1, arg2, arg3, arg4) {
+        arg0.append(getStringFromWasm0(arg1, arg2), getStringFromWasm0(arg3, arg4));
+      }, arguments);
+    },
+    __wbg_buffer_60b8043cd926067d: function(arg0) {
+      const ret = arg0.buffer;
+      return ret;
+    },
+    __wbg_byobRequest_6342e5f2b232c0f9: function(arg0) {
+      const ret = arg0.byobRequest;
+      return isLikeNone(ret) ? 0 : addToExternrefTable0(ret);
+    },
+    __wbg_byteLength_607b856aa6c5a508: function(arg0) {
+      const ret = arg0.byteLength;
+      return ret;
+    },
+    __wbg_byteOffset_b26b63681c83856c: function(arg0) {
+      const ret = arg0.byteOffset;
+      return ret;
+    },
+    __wbg_call_2d781c1f4d5c0ef8: function() {
+      return handleError(function(arg0, arg1, arg2) {
+        const ret = arg0.call(arg1, arg2);
+        return ret;
+      }, arguments);
+    },
+    __wbg_call_e133b57c9155d22c: function() {
+      return handleError(function(arg0, arg1) {
+        const ret = arg0.call(arg1);
+        return ret;
+      }, arguments);
+    },
+    __wbg_call_f858478a02f9600f: function() {
+      return handleError(function(arg0, arg1, arg2, arg3, arg4) {
+        const ret = arg0.call(arg1, arg2, arg3, arg4);
+        return ret;
+      }, arguments);
+    },
+    __wbg_clearTimeout_113b1cde814ec762: function(arg0) {
+      const ret = clearTimeout(arg0);
+      return ret;
+    },
+    __wbg_close_690d36108c557337: function() {
+      return handleError(function(arg0) {
+        arg0.close();
+      }, arguments);
+    },
+    __wbg_close_737b4b1fbc658540: function() {
+      return handleError(function(arg0) {
+        arg0.close();
+      }, arguments);
+    },
+    __wbg_crypto_38df2bab126b63dc: function(arg0) {
+      const ret = arg0.crypto;
+      return ret;
+    },
+    __wbg_delete_bddb69df015ae01b: function() {
+      return handleError(function(arg0, arg1, arg2) {
+        const ret = arg0.delete(getStringFromWasm0(arg1, arg2));
+        return ret;
+      }, arguments);
+    },
+    __wbg_digest_cb8de04aa7e6b6f1: function() {
+      return handleError(function(arg0, arg1, arg2, arg3) {
+        const ret = arg0.digest(getStringFromWasm0(arg1, arg2), arg3);
+        return ret;
+      }, arguments);
+    },
+    __wbg_done_08ce71ee07e3bd17: function(arg0) {
+      const ret = arg0.done;
+      return ret;
+    },
+    __wbg_enqueue_ec3552838b4b7fbf: function() {
+      return handleError(function(arg0, arg1) {
+        arg0.enqueue(arg1);
+      }, arguments);
+    },
+    __wbg_entries_e8a20ff8c9757101: function(arg0) {
+      const ret = Object.entries(arg0);
+      return ret;
+    },
+    __wbg_error_a6fa202b58aa1cd3: function(arg0, arg1) {
+      let deferred0_0;
+      let deferred0_1;
+      try {
+        deferred0_0 = arg0;
+        deferred0_1 = arg1;
+        console.error(getStringFromWasm0(arg0, arg1));
+      } finally {
+        wasm.__wbindgen_free(deferred0_0, deferred0_1, 1);
+      }
+    },
+    __wbg_from_4bdf88943703fd48: function(arg0) {
+      const ret = Array.from(arg0);
+      return ret;
+    },
+    __wbg_getAll_576fde6e76c7d925: function() {
+      return handleError(function(arg0, arg1, arg2) {
+        const ret = arg0.getAll(getStringFromWasm0(arg1, arg2));
+        return ret;
+      }, arguments);
+    },
+    __wbg_getRandomValues_3f44b700395062e5: function() {
+      return handleError(function(arg0, arg1) {
+        globalThis.crypto.getRandomValues(getArrayU8FromWasm0(arg0, arg1));
+      }, arguments);
+    },
+    __wbg_getRandomValues_c44a50d8cfdaebeb: function() {
+      return handleError(function(arg0, arg1) {
+        arg0.getRandomValues(arg1);
+      }, arguments);
+    },
+    __wbg_get_326e41e095fb2575: function() {
+      return handleError(function(arg0, arg1) {
+        const ret = Reflect.get(arg0, arg1);
+        return ret;
+      }, arguments);
+    },
+    __wbg_get_3ef1eba1850ade27: function() {
+      return handleError(function(arg0, arg1) {
+        const ret = Reflect.get(arg0, arg1);
+        return ret;
+      }, arguments);
+    },
+    __wbg_get_a8ee5c45dabc1b3b: function(arg0, arg1) {
+      const ret = arg0[arg1 >>> 0];
+      return ret;
+    },
+    __wbg_get_unchecked_329cfe50afab7352: function(arg0, arg1) {
+      const ret = arg0[arg1 >>> 0];
+      return ret;
+    },
+    __wbg_get_with_ref_key_6412cf3094599694: function(arg0, arg1) {
+      const ret = arg0[arg1];
+      return ret;
+    },
+    __wbg_instanceof_AbortSignal_0173156d14d8c44d: function(arg0) {
+      let result;
+      try {
+        result = arg0 instanceof AbortSignal;
+      } catch (_) {
+        result = false;
+      }
+      const ret = result;
+      return ret;
+    },
+    __wbg_instanceof_ArrayBuffer_101e2bf31071a9f6: function(arg0) {
+      let result;
+      try {
+        result = arg0 instanceof ArrayBuffer;
+      } catch (_) {
+        result = false;
+      }
+      const ret = result;
+      return ret;
+    },
+    __wbg_instanceof_Crypto_5c2a4c15287b0332: function(arg0) {
+      let result;
+      try {
+        result = arg0 instanceof Crypto;
+      } catch (_) {
+        result = false;
+      }
+      const ret = result;
+      return ret;
+    },
+    __wbg_instanceof_Uint8Array_740438561a5b956d: function(arg0) {
+      let result;
+      try {
+        result = arg0 instanceof Uint8Array;
+      } catch (_) {
+        result = false;
+      }
+      const ret = result;
+      return ret;
+    },
+    __wbg_iterator_d8f549ec8fb061b1: function() {
+      const ret = Symbol.iterator;
+      return ret;
+    },
+    __wbg_length_b3416cf66a5452c8: function(arg0) {
+      const ret = arg0.length;
+      return ret;
+    },
+    __wbg_length_ea16607d7b61445b: function(arg0) {
+      const ret = arg0.length;
+      return ret;
+    },
+    __wbg_log_524eedafa26daa59: function(arg0) {
+      console.log(arg0);
+    },
+    __wbg_msCrypto_bd5a034af96bcba6: function(arg0) {
+      const ret = arg0.msCrypto;
+      return ret;
+    },
+    __wbg_new_0837727332ac86ba: function() {
+      return handleError(function() {
+        const ret = new Headers();
+        return ret;
+      }, arguments);
+    },
+    __wbg_new_227d7c05414eb861: function() {
+      const ret = new Error();
+      return ret;
+    },
+    __wbg_new_5f486cdf45a04d78: function(arg0) {
+      const ret = new Uint8Array(arg0);
+      return ret;
+    },
+    __wbg_new_ab79df5bd7c26067: function() {
+      const ret = new Object();
+      return ret;
+    },
+    __wbg_new_d15cb560a6a0e5f0: function(arg0, arg1) {
+      const ret = new Error(getStringFromWasm0(arg0, arg1));
+      return ret;
+    },
+    __wbg_new_from_slice_22da9388ac046e50: function(arg0, arg1) {
+      const ret = new Uint8Array(getArrayU8FromWasm0(arg0, arg1));
+      return ret;
+    },
+    __wbg_new_typed_aaaeaf29cf802876: function(arg0, arg1) {
+      try {
+        var state0 = { a: arg0, b: arg1 };
+        var cb0 = (arg02, arg12) => {
+          const a = state0.a;
+          state0.a = 0;
+          try {
+            return wasm_bindgen__convert__closures_____invoke__hb864778e5a95f086(a, state0.b, arg02, arg12);
+          } finally {
+            state0.a = a;
+          }
+        };
+        const ret = new Promise(cb0);
+        return ret;
+      } finally {
+        state0.a = state0.b = 0;
+      }
+    },
+    __wbg_new_with_byte_offset_and_length_b2ec5bf7b2f35743: function(arg0, arg1, arg2) {
+      const ret = new Uint8Array(arg0, arg1 >>> 0, arg2 >>> 0);
+      return ret;
+    },
+    __wbg_new_with_into_underlying_source_b45133df5ff75afa: function(arg0, arg1) {
+      const ret = new ReadableStream(IntoUnderlyingSource.__wrap(arg0), arg1);
+      return ret;
+    },
+    __wbg_new_with_length_3259a525196bd8cc: function(arg0) {
+      const ret = new Array(arg0 >>> 0);
+      return ret;
+    },
+    __wbg_new_with_length_825018a1616e9e55: function(arg0) {
+      const ret = new Uint8Array(arg0 >>> 0);
+      return ret;
+    },
+    __wbg_new_with_opt_readable_stream_and_init_15b79ab5fa39d080: function() {
+      return handleError(function(arg0, arg1) {
+        const ret = new Response(arg0, arg1);
+        return ret;
+      }, arguments);
+    },
+    __wbg_next_11b99ee6237339e3: function() {
+      return handleError(function(arg0) {
+        const ret = arg0.next();
+        return ret;
+      }, arguments);
+    },
+    __wbg_next_e01a967809d1aa68: function(arg0) {
+      const ret = arg0.next;
+      return ret;
+    },
+    __wbg_node_84ea875411254db1: function(arg0) {
+      const ret = arg0.node;
+      return ret;
+    },
+    __wbg_now_16f0c993d5dd6c27: function() {
+      const ret = Date.now();
+      return ret;
+    },
+    __wbg_now_e7c6795a7f81e10f: function(arg0) {
+      const ret = arg0.now();
+      return ret;
+    },
+    __wbg_performance_3fcf6e32a7e1ed0a: function(arg0) {
+      const ret = arg0.performance;
+      return ret;
+    },
+    __wbg_process_44c7a14e11e9f69e: function(arg0) {
+      const ret = arg0.process;
+      return ret;
+    },
+    __wbg_prototypesetcall_d62e5099504357e6: function(arg0, arg1, arg2) {
+      Uint8Array.prototype.set.call(getArrayU8FromWasm0(arg0, arg1), arg2);
+    },
+    __wbg_queueMicrotask_0c399741342fb10f: function(arg0) {
+      const ret = arg0.queueMicrotask;
+      return ret;
+    },
+    __wbg_queueMicrotask_a082d78ce798393e: function(arg0) {
+      queueMicrotask(arg0);
+    },
+    __wbg_randomFillSync_6c25eac9869eb53c: function() {
+      return handleError(function(arg0, arg1) {
+        arg0.randomFillSync(arg1);
+      }, arguments);
+    },
+    __wbg_require_b4edbdcf3e2a1ef0: function() {
+      return handleError(function() {
+        const ret = module.require;
+        return ret;
+      }, arguments);
+    },
+    __wbg_resolve_ae8d83246e5bcc12: function(arg0) {
+      const ret = Promise.resolve(arg0);
+      return ret;
+    },
+    __wbg_respond_e286ee502e7cf7e4: function() {
+      return handleError(function(arg0, arg1) {
+        arg0.respond(arg1 >>> 0);
+      }, arguments);
+    },
+    __wbg_setTimeout_ef24d2fc3ad97385: function() {
+      return handleError(function(arg0, arg1) {
+        const ret = setTimeout(arg0, arg1);
+        return ret;
+      }, arguments);
+    },
+    __wbg_set_282384002438957f: function(arg0, arg1, arg2) {
+      arg0[arg1 >>> 0] = arg2;
+    },
+    __wbg_set_7eaa4f96924fd6b3: function() {
+      return handleError(function(arg0, arg1, arg2) {
+        const ret = Reflect.set(arg0, arg1, arg2);
+        return ret;
+      }, arguments);
+    },
+    __wbg_set_8c0b3ffcf05d61c2: function(arg0, arg1, arg2) {
+      arg0.set(getArrayU8FromWasm0(arg1, arg2));
+    },
+    __wbg_set_9b44de9403b9716a: function() {
+      return handleError(function(arg0, arg1, arg2, arg3, arg4) {
+        const ret = arg0.set(getStringFromWasm0(arg1, arg2), getStringFromWasm0(arg3, arg4));
+        return ret;
+      }, arguments);
+    },
+    __wbg_set_headers_bf56980ea1a65acb: function(arg0, arg1) {
+      arg0.headers = arg1;
+    },
+    __wbg_set_high_water_mark_1ac059fa0566c2fc: function(arg0, arg1) {
+      arg0.highWaterMark = arg1;
+    },
+    __wbg_set_status_b80d37d9d23276c4: function(arg0, arg1) {
+      arg0.status = arg1;
+    },
+    __wbg_stack_3b0d974bbf31e44f: function(arg0, arg1) {
+      const ret = arg1.stack;
+      const ptr1 = passStringToWasm0(ret, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
+      const len1 = WASM_VECTOR_LEN;
+      getDataViewMemory0().setInt32(arg0 + 4 * 1, len1, true);
+      getDataViewMemory0().setInt32(arg0 + 4 * 0, ptr1, true);
+    },
+    __wbg_static_accessor_GLOBAL_8adb955bd33fac2f: function() {
+      const ret = typeof global === "undefined" ? null : global;
+      return isLikeNone(ret) ? 0 : addToExternrefTable0(ret);
+    },
+    __wbg_static_accessor_GLOBAL_THIS_ad356e0db91c7913: function() {
+      const ret = typeof globalThis === "undefined" ? null : globalThis;
+      return isLikeNone(ret) ? 0 : addToExternrefTable0(ret);
+    },
+    __wbg_static_accessor_SELF_f207c857566db248: function() {
+      const ret = typeof self === "undefined" ? null : self;
+      return isLikeNone(ret) ? 0 : addToExternrefTable0(ret);
+    },
+    __wbg_static_accessor_WINDOW_bb9f1ba69d61b386: function() {
+      const ret = typeof window === "undefined" ? null : window;
+      return isLikeNone(ret) ? 0 : addToExternrefTable0(ret);
+    },
+    __wbg_subarray_a068d24e39478a8a: function(arg0, arg1, arg2) {
+      const ret = arg0.subarray(arg1 >>> 0, arg2 >>> 0);
+      return ret;
+    },
+    __wbg_subtle_c060fa3eb5c6248d: function(arg0) {
+      const ret = arg0.subtle;
+      return ret;
+    },
+    __wbg_then_098abe61755d12f6: function(arg0, arg1) {
+      const ret = arg0.then(arg1);
+      return ret;
+    },
+    __wbg_then_9e335f6dd892bc11: function(arg0, arg1, arg2) {
+      const ret = arg0.then(arg1, arg2);
+      return ret;
+    },
+    __wbg_torclient_new: function(arg0) {
+      const ret = TorClient.__wrap(arg0);
+      return ret;
+    },
+    __wbg_tryLock_5d7357252b3473bd: function() {
+      return handleError(function(arg0) {
+        const ret = arg0.tryLock();
+        return ret;
+      }, arguments);
+    },
+    __wbg_unlock_2d843e9896897e90: function() {
+      return handleError(function(arg0) {
+        const ret = arg0.unlock();
+        return ret;
+      }, arguments);
+    },
+    __wbg_value_21fc78aab0322612: function(arg0) {
+      const ret = arg0.value;
+      return ret;
+    },
+    __wbg_versions_276b2795b1c6a219: function(arg0) {
+      const ret = arg0.versions;
+      return ret;
+    },
+    __wbg_view_f68a712e7315f8b2: function(arg0) {
+      const ret = arg0.view;
+      return isLikeNone(ret) ? 0 : addToExternrefTable0(ret);
+    },
+    __wbindgen_cast_0000000000000001: function(arg0, arg1) {
+      const ret = makeMutClosure(arg0, arg1, wasm.wasm_bindgen__closure__destroy__h9b79478a56146cd2, wasm_bindgen__convert__closures_____invoke__h5c591e637e5094b1);
+      return ret;
+    },
+    __wbindgen_cast_0000000000000002: function(arg0, arg1) {
+      const ret = makeMutClosure(arg0, arg1, wasm.wasm_bindgen__closure__destroy__h4d8dd6cb42c8a695, wasm_bindgen__convert__closures_____invoke__h69c112f8841b438b);
+      return ret;
+    },
+    __wbindgen_cast_0000000000000003: function(arg0, arg1) {
+      const ret = makeMutClosure(arg0, arg1, wasm.wasm_bindgen__closure__destroy__h1e3ac41672e7b2ad, wasm_bindgen__convert__closures_____invoke__hc2bcdd2c6020290d);
+      return ret;
+    },
+    __wbindgen_cast_0000000000000004: function(arg0, arg1) {
+      const ret = getArrayU8FromWasm0(arg0, arg1);
+      return ret;
+    },
+    __wbindgen_cast_0000000000000005: function(arg0, arg1) {
+      const ret = getStringFromWasm0(arg0, arg1);
+      return ret;
+    },
+    __wbindgen_init_externref_table: function() {
+      const table = wasm.__wbindgen_externrefs;
+      const offset = table.grow(4);
+      table.set(0, void 0);
+      table.set(offset + 0, void 0);
+      table.set(offset + 1, null);
+      table.set(offset + 2, true);
+      table.set(offset + 3, false);
+    }
+  };
+  return {
+    __proto__: null,
+    "./tor_js_bg.js": import0
+  };
+}
+function wasm_bindgen__convert__closures_____invoke__h69c112f8841b438b(arg0, arg1) {
+  wasm.wasm_bindgen__convert__closures_____invoke__h69c112f8841b438b(arg0, arg1);
+}
+function wasm_bindgen__convert__closures_____invoke__h5c591e637e5094b1(arg0, arg1, arg2) {
+  wasm.wasm_bindgen__convert__closures_____invoke__h5c591e637e5094b1(arg0, arg1, arg2);
+}
+function wasm_bindgen__convert__closures_____invoke__hc2bcdd2c6020290d(arg0, arg1, arg2) {
+  const ret = wasm.wasm_bindgen__convert__closures_____invoke__hc2bcdd2c6020290d(arg0, arg1, arg2);
+  if (ret[1]) {
+    throw takeFromExternrefTable0(ret[0]);
+  }
+}
+function wasm_bindgen__convert__closures_____invoke__hb864778e5a95f086(arg0, arg1, arg2, arg3) {
+  wasm.wasm_bindgen__convert__closures_____invoke__hb864778e5a95f086(arg0, arg1, arg2, arg3);
+}
+var __wbindgen_enum_ReadableStreamType = ["bytes"];
+var IntoUnderlyingByteSourceFinalization = typeof FinalizationRegistry === "undefined" ? { register: () => {
+}, unregister: () => {
+} } : new FinalizationRegistry((ptr) => wasm.__wbg_intounderlyingbytesource_free(ptr >>> 0, 1));
+var IntoUnderlyingSinkFinalization = typeof FinalizationRegistry === "undefined" ? { register: () => {
+}, unregister: () => {
+} } : new FinalizationRegistry((ptr) => wasm.__wbg_intounderlyingsink_free(ptr >>> 0, 1));
+var IntoUnderlyingSourceFinalization = typeof FinalizationRegistry === "undefined" ? { register: () => {
+}, unregister: () => {
+} } : new FinalizationRegistry((ptr) => wasm.__wbg_intounderlyingsource_free(ptr >>> 0, 1));
+var TorClientFinalization = typeof FinalizationRegistry === "undefined" ? { register: () => {
+}, unregister: () => {
+} } : new FinalizationRegistry((ptr) => wasm.__wbg_torclient_free(ptr >>> 0, 1));
+var TorClientOptionsFinalization = typeof FinalizationRegistry === "undefined" ? { register: () => {
+}, unregister: () => {
+} } : new FinalizationRegistry((ptr) => wasm.__wbg_torclientoptions_free(ptr >>> 0, 1));
+function addToExternrefTable0(obj) {
+  const idx = wasm.__externref_table_alloc();
+  wasm.__wbindgen_externrefs.set(idx, obj);
+  return idx;
+}
+function _assertClass(instance, klass) {
+  if (!(instance instanceof klass)) {
+    throw new Error(`expected instance of ${klass.name}`);
+  }
+}
+var CLOSURE_DTORS = typeof FinalizationRegistry === "undefined" ? { register: () => {
+}, unregister: () => {
+} } : new FinalizationRegistry((state) => state.dtor(state.a, state.b));
+function debugString(val) {
+  const type = typeof val;
+  if (type == "number" || type == "boolean" || val == null) {
+    return `${val}`;
+  }
+  if (type == "string") {
+    return `"${val}"`;
+  }
+  if (type == "symbol") {
+    const description = val.description;
+    if (description == null) {
+      return "Symbol";
+    } else {
+      return `Symbol(${description})`;
+    }
+  }
+  if (type == "function") {
+    const name = val.name;
+    if (typeof name == "string" && name.length > 0) {
+      return `Function(${name})`;
+    } else {
+      return "Function";
+    }
+  }
+  if (Array.isArray(val)) {
+    const length = val.length;
+    let debug = "[";
+    if (length > 0) {
+      debug += debugString(val[0]);
+    }
+    for (let i = 1; i < length; i++) {
+      debug += ", " + debugString(val[i]);
+    }
+    debug += "]";
+    return debug;
+  }
+  const builtInMatches = /\[object ([^\]]+)\]/.exec(toString.call(val));
+  let className;
+  if (builtInMatches && builtInMatches.length > 1) {
+    className = builtInMatches[1];
+  } else {
+    return toString.call(val);
+  }
+  if (className == "Object") {
+    try {
+      return "Object(" + JSON.stringify(val) + ")";
+    } catch (_) {
+      return "Object";
+    }
+  }
+  if (val instanceof Error) {
+    return `${val.name}: ${val.message}
+${val.stack}`;
+  }
+  return className;
+}
+function getArrayU8FromWasm0(ptr, len) {
+  ptr = ptr >>> 0;
+  return getUint8ArrayMemory0().subarray(ptr / 1, ptr / 1 + len);
+}
+var cachedDataViewMemory0 = null;
+function getDataViewMemory0() {
+  if (cachedDataViewMemory0 === null || cachedDataViewMemory0.buffer.detached === true || cachedDataViewMemory0.buffer.detached === void 0 && cachedDataViewMemory0.buffer !== wasm.memory.buffer) {
+    cachedDataViewMemory0 = new DataView(wasm.memory.buffer);
+  }
+  return cachedDataViewMemory0;
+}
+function getStringFromWasm0(ptr, len) {
+  ptr = ptr >>> 0;
+  return decodeText(ptr, len);
+}
+var cachedUint8ArrayMemory0 = null;
+function getUint8ArrayMemory0() {
+  if (cachedUint8ArrayMemory0 === null || cachedUint8ArrayMemory0.byteLength === 0) {
+    cachedUint8ArrayMemory0 = new Uint8Array(wasm.memory.buffer);
+  }
+  return cachedUint8ArrayMemory0;
+}
+function handleError(f, args) {
+  try {
+    return f.apply(this, args);
+  } catch (e) {
+    const idx = addToExternrefTable0(e);
+    wasm.__wbindgen_exn_store(idx);
+  }
+}
+function isLikeNone(x) {
+  return x === void 0 || x === null;
+}
+function makeMutClosure(arg0, arg1, dtor, f) {
+  const state = { a: arg0, b: arg1, cnt: 1, dtor };
+  const real = (...args) => {
+    state.cnt++;
+    const a = state.a;
+    state.a = 0;
+    try {
+      return f(a, state.b, ...args);
+    } finally {
+      state.a = a;
+      real._wbg_cb_unref();
+    }
+  };
+  real._wbg_cb_unref = () => {
+    if (--state.cnt === 0) {
+      state.dtor(state.a, state.b);
+      state.a = 0;
+      CLOSURE_DTORS.unregister(state);
+    }
+  };
+  CLOSURE_DTORS.register(real, state, state);
+  return real;
+}
+function passStringToWasm0(arg, malloc, realloc) {
+  if (realloc === void 0) {
+    const buf = cachedTextEncoder.encode(arg);
+    const ptr2 = malloc(buf.length, 1) >>> 0;
+    getUint8ArrayMemory0().subarray(ptr2, ptr2 + buf.length).set(buf);
+    WASM_VECTOR_LEN = buf.length;
+    return ptr2;
+  }
+  let len = arg.length;
+  let ptr = malloc(len, 1) >>> 0;
+  const mem = getUint8ArrayMemory0();
+  let offset = 0;
+  for (; offset < len; offset++) {
+    const code = arg.charCodeAt(offset);
+    if (code > 127) break;
+    mem[ptr + offset] = code;
+  }
+  if (offset !== len) {
+    if (offset !== 0) {
+      arg = arg.slice(offset);
+    }
+    ptr = realloc(ptr, len, len = offset + arg.length * 3, 1) >>> 0;
+    const view = getUint8ArrayMemory0().subarray(ptr + offset, ptr + len);
+    const ret = cachedTextEncoder.encodeInto(arg, view);
+    offset += ret.written;
+    ptr = realloc(ptr, len, offset, 1) >>> 0;
+  }
+  WASM_VECTOR_LEN = offset;
+  return ptr;
+}
+function takeFromExternrefTable0(idx) {
+  const value = wasm.__wbindgen_externrefs.get(idx);
+  wasm.__externref_table_dealloc(idx);
+  return value;
+}
+var cachedTextDecoder = new TextDecoder("utf-8", { ignoreBOM: true, fatal: true });
+cachedTextDecoder.decode();
+var MAX_SAFARI_DECODE_BYTES = 2146435072;
+var numBytesDecoded = 0;
+function decodeText(ptr, len) {
+  numBytesDecoded += len;
+  if (numBytesDecoded >= MAX_SAFARI_DECODE_BYTES) {
+    cachedTextDecoder = new TextDecoder("utf-8", { ignoreBOM: true, fatal: true });
+    cachedTextDecoder.decode();
+    numBytesDecoded = len;
+  }
+  return cachedTextDecoder.decode(getUint8ArrayMemory0().subarray(ptr, ptr + len));
+}
+var cachedTextEncoder = new TextEncoder();
+if (!("encodeInto" in cachedTextEncoder)) {
+  cachedTextEncoder.encodeInto = function(arg, view) {
+    const buf = cachedTextEncoder.encode(arg);
+    view.set(buf);
+    return {
+      read: arg.length,
+      written: buf.length
+    };
+  };
+}
+var WASM_VECTOR_LEN = 0;
+var wasmModule;
+var wasm;
+function __wbg_finalize_init(instance, module2) {
+  wasm = instance.exports;
+  wasmModule = module2;
+  cachedDataViewMemory0 = null;
+  cachedUint8ArrayMemory0 = null;
+  wasm.__wbindgen_start();
+  return wasm;
+}
+async function __wbg_load(module2, imports) {
+  if (typeof Response === "function" && module2 instanceof Response) {
+    if (typeof WebAssembly.instantiateStreaming === "function") {
+      try {
+        return await WebAssembly.instantiateStreaming(module2, imports);
+      } catch (e) {
+        const validResponse = module2.ok && expectedResponseType(module2.type);
+        if (validResponse && module2.headers.get("Content-Type") !== "application/wasm") {
+          console.warn("`WebAssembly.instantiateStreaming` failed because your server does not serve Wasm with `application/wasm` MIME type. Falling back to `WebAssembly.instantiate` which is slower. Original error:\n", e);
+        } else {
+          throw e;
+        }
+      }
+    }
+    const bytes = await module2.arrayBuffer();
+    return await WebAssembly.instantiate(bytes, imports);
+  } else {
+    const instance = await WebAssembly.instantiate(module2, imports);
+    if (instance instanceof WebAssembly.Instance) {
+      return { instance, module: module2 };
+    } else {
+      return instance;
+    }
+  }
+  function expectedResponseType(type) {
+    switch (type) {
+      case "basic":
+      case "cors":
+      case "default":
+        return true;
+    }
+    return false;
+  }
+}
+async function __wbg_init(module_or_path) {
+  if (wasm !== void 0) return wasm;
+  if (module_or_path !== void 0) {
+    if (Object.getPrototypeOf(module_or_path) === Object.prototype) {
+      ({ module_or_path } = module_or_path);
+    } else {
+      console.warn("using deprecated parameters for the initialization function; pass a single object instead");
+    }
+  }
+  if (module_or_path === void 0) {
+    module_or_path = new URL("tor_js_bg.wasm", import.meta.url);
+  }
+  const imports = __wbg_get_imports();
+  if (typeof module_or_path === "string" || typeof Request === "function" && module_or_path instanceof Request || typeof URL === "function" && module_or_path instanceof URL) {
+    module_or_path = fetch(module_or_path);
+  }
+  const { instance, module: module2 } = await __wbg_load(await module_or_path, imports);
+  return __wbg_finalize_init(instance, module2);
+}
+
+// src/wasm.ts
+var LEVEL_ORDER = ["trace", "debug", "info", "warn", "error"];
+function levelIndex(level) {
+  const idx = LEVEL_ORDER.indexOf(level);
+  return idx === -1 ? 1 : idx;
+}
+var logListeners = /* @__PURE__ */ new Map();
+function syncWasmLogLevel() {
+  let broadestIdx = LEVEL_ORDER.length - 1;
+  for (const listener of logListeners.values()) {
+    if (listener.levelIdx < broadestIdx) {
+      broadestIdx = listener.levelIdx;
+    }
+  }
+  setLogLevel(LEVEL_ORDER[broadestIdx]);
+}
+function addLogListener(cb, level = "debug") {
+  logListeners.set(cb, { callback: cb, levelIdx: levelIndex(level) });
+  syncWasmLogLevel();
+  return () => {
+    logListeners.delete(cb);
+    if (logListeners.size > 0) {
+      syncWasmLogLevel();
+    }
+  };
+}
+function setListenerLevel(cb, level) {
+  const listener = logListeners.get(cb);
+  if (listener) {
+    listener.levelIdx = levelIndex(level);
+    syncWasmLogLevel();
+  }
+}
+var initPromise = null;
+var customWasmUrl;
+var wasmSourceProvider;
+function setWasmUrl(url) {
+  if (initPromise) {
+    throw new Error("setWasmUrl() must be called before any TorClient is created");
+  }
+  customWasmUrl = url;
+}
+function setWasmSourceProvider(provider) {
+  if (initPromise) {
+    throw new Error("setWasmSourceProvider() must be called before any TorClient is created");
+  }
+  wasmSourceProvider = provider;
+}
+async function ensureWasmInitialized() {
+  if (initPromise) return initPromise;
+  initPromise = doInit();
+  return initPromise;
+}
+async function doInit() {
+  if (customWasmUrl) {
+    await __wbg_init({ module_or_path: customWasmUrl });
+  } else if (wasmSourceProvider) {
+    await __wbg_init({ module_or_path: await wasmSourceProvider() });
+  } else {
+    throw new Error(
+      "No WASM source configured. Import from a specific entry point (tor-js/wasm-base64, tor-js/wasm-cdn, or tor-js/wasm-file) or call setWasmUrl() before creating a TorClient."
+    );
+  }
+  init();
+  setLogCallback((level, target, message) => {
+    const lvl = levelIndex(level);
+    for (const listener of logListeners.values()) {
+      if (lvl >= listener.levelIdx) {
+        listener.callback(level, target, message);
+      }
+    }
+  });
+}
+
+// src/Log.ts
+var Log = class _Log {
+  rawLog;
+  parentStartTime;
+  namePrefix;
+  constructor(params = {}) {
+    this.parentStartTime = params.parentStartTime ?? Date.now();
+    this.namePrefix = params.namePrefix ?? "";
+    this.rawLog = params.rawLog ?? this.defaultRawLog.bind(this);
+  }
+  child(name) {
+    const newPrefix = this.namePrefix ? `${this.namePrefix}.${name}` : name;
+    return new _Log({
+      rawLog: this.rawLog,
+      parentStartTime: this.parentStartTime,
+      namePrefix: newPrefix
+    });
+  }
+  trace(...args) {
+    this.log("trace", ...args);
+  }
+  debug(...args) {
+    this.log("debug", ...args);
+  }
+  info(...args) {
+    this.log("info", ...args);
+  }
+  warn(...args) {
+    this.log("warn", ...args);
+  }
+  error(...args) {
+    this.log("error", ...args);
+  }
+  /** @internal Create a callback for WASM setLogCallback */
+  _makeWasmCallback() {
+    const levels = /* @__PURE__ */ new Set(["trace", "debug", "info", "warn", "error"]);
+    return (level, target, message) => {
+      if (!levels.has(level)) {
+        this.log("error", `unexpected log level from WASM: ${JSON.stringify(level)}`);
+        level = "debug";
+      }
+      this.child(target).log(level, message);
+    };
+  }
+  log(level, ...args) {
+    const elapsed = Date.now() - this.parentStartTime;
+    const timestamp = formatTimestamp(elapsed);
+    if (this.namePrefix) {
+      this.rawLog(level, `[${timestamp}]`, `[${this.namePrefix}]`, ...args);
+    } else {
+      this.rawLog(level, `[${timestamp}]`, ...args);
+    }
+  }
+  defaultRawLog(level, ...args) {
+    console[level](...args);
+  }
+};
+function formatTimestamp(elapsedMs) {
+  const totalSeconds = Math.floor(elapsedMs / 1e3);
+  const milliseconds = elapsedMs % 1e3;
+  const ms = String(milliseconds).padStart(3, "0");
+  const days = Math.floor(totalSeconds / 86400);
+  const hours = Math.floor(totalSeconds % 86400 / 3600);
+  const minutes = Math.floor(totalSeconds % 3600 / 60);
+  const seconds = totalSeconds % 60;
+  if (days > 0) {
+    return `${days}d ${p2(hours)}:${p2(minutes)}:${p2(seconds)}.${ms}`;
+  }
+  if (hours > 0) {
+    return `${p2(hours)}:${p2(minutes)}:${p2(seconds)}.${ms}`;
+  }
+  if (minutes > 0) {
+    return `${p2(minutes)}:${p2(seconds)}.${ms}`;
+  }
+  return `${p2(seconds)}.${ms}`;
+}
+function p2(n) {
+  return String(n).padStart(2, "0");
+}
+
+// src/storage/index.ts
+var storage_exports = {};
+__export(storage_exports, {
+  FilesystemStorage: () => FilesystemStorage,
+  IndexedDBStorage: () => IndexedDBStorage,
+  MemoryStorage: () => MemoryStorage,
+  addLocking: () => addLocking,
+  createAutoStorage: () => createAutoStorage
+});
+
+// src/storage/memory.ts
+var MemoryStorage = class {
+  data = /* @__PURE__ */ new Map();
+  locked = false;
+  async get(key) {
+    return this.data.get(key) ?? null;
+  }
+  async set(key, value) {
+    this.data.set(key, value);
+  }
+  async delete(key) {
+    this.data.delete(key);
+  }
+  async keys(prefix) {
+    return [...this.data.keys()].filter((k) => k.startsWith(prefix)).sort();
+  }
+  async getAll(prefix) {
+    const result = [];
+    for (const [key, value] of this.data) {
+      if (key.startsWith(prefix)) {
+        result.push([key, value]);
+      }
+    }
+    return result;
+  }
+  async tryLock() {
+    if (this.locked) return false;
+    this.locked = true;
+    return true;
+  }
+  async unlock() {
+    this.locked = false;
+  }
+};
+
+// src/storage/indexeddb.ts
+var IndexedDBStorage = class {
+  dbName;
+  storeName = "keyvalue";
+  dbPromise = null;
+  constructor(name = "tor-js") {
+    this.dbName = name;
+  }
+  getDB() {
+    if (!this.dbPromise) {
+      this.dbPromise = new Promise((resolve, reject) => {
+        const request = indexedDB.open(this.dbName, 1);
+        request.onerror = () => reject(request.error);
+        request.onsuccess = () => resolve(request.result);
+        request.onupgradeneeded = (event) => {
+          const db = event.target.result;
+          if (!db.objectStoreNames.contains(this.storeName)) {
+            db.createObjectStore(this.storeName);
+          }
+        };
+      });
+    }
+    return this.dbPromise;
+  }
+  async get(key) {
+    const db = await this.getDB();
+    return new Promise((resolve, reject) => {
+      const tx = db.transaction(this.storeName, "readonly");
+      const store = tx.objectStore(this.storeName);
+      const request = store.get(key);
+      request.onerror = () => reject(request.error);
+      request.onsuccess = () => {
+        resolve(request.result === void 0 ? null : request.result);
+      };
+    });
+  }
+  async set(key, value) {
+    const db = await this.getDB();
+    return new Promise((resolve, reject) => {
+      const tx = db.transaction(this.storeName, "readwrite");
+      const store = tx.objectStore(this.storeName);
+      const request = store.put(value, key);
+      request.onerror = () => reject(request.error);
+      request.onsuccess = () => resolve();
+    });
+  }
+  async delete(key) {
+    const db = await this.getDB();
+    return new Promise((resolve, reject) => {
+      const tx = db.transaction(this.storeName, "readwrite");
+      const store = tx.objectStore(this.storeName);
+      const request = store.delete(key);
+      request.onerror = () => reject(request.error);
+      request.onsuccess = () => resolve();
+    });
+  }
+  async keys(prefix) {
+    const db = await this.getDB();
+    return new Promise((resolve, reject) => {
+      const tx = db.transaction(this.storeName, "readonly");
+      const store = tx.objectStore(this.storeName);
+      const request = store.getAllKeys();
+      request.onerror = () => reject(request.error);
+      request.onsuccess = () => {
+        const allKeys = request.result;
+        resolve(allKeys.filter((k) => k.startsWith(prefix)).sort());
+      };
+    });
+  }
+  async getAll(prefix) {
+    const db = await this.getDB();
+    return new Promise((resolve, reject) => {
+      const tx = db.transaction(this.storeName, "readonly");
+      const store = tx.objectStore(this.storeName);
+      const keysReq = store.getAllKeys();
+      const valsReq = store.getAll();
+      tx.onerror = () => reject(tx.error);
+      tx.oncomplete = () => {
+        const keys = keysReq.result;
+        const vals = valsReq.result;
+        const result = [];
+        for (let i = 0; i < keys.length; i++) {
+          if (keys[i].startsWith(prefix)) {
+            result.push([keys[i], vals[i]]);
+          }
+        }
+        resolve(result);
+      };
+    });
+  }
+};
+
+// src/storage/node-deps.ts
+var promise;
+function getNodeDeps() {
+  if (!promise) {
+    promise = (async () => {
+      const [fs, fsSync, os, path] = await Promise.all([
+        import("fs/promises").then((m) => m.default ?? m),
+        import("fs").then((m) => m.default ?? m),
+        import("os").then((m) => m.default ?? m),
+        import("path").then((m) => m.default ?? m)
+      ]);
+      return { fs, fsSync, os, path };
+    })();
+  }
+  return promise;
+}
+
+// src/storage/filesystem.ts
+function isNodeError(err) {
+  return err instanceof Error && "code" in err;
+}
+function mangleKey(key) {
+  let result = "";
+  for (let i = 0; i < key.length; i++) {
+    const code = key.charCodeAt(i);
+    if (code >= 97 && code <= 122 || // a-z
+    code >= 65 && code <= 90 || // A-Z
+    code >= 48 && code <= 57) {
+      result += key[i];
+    } else if (code <= 255) {
+      result += "_" + code.toString(16).padStart(2, "0") + "_";
+    } else {
+      result += "_" + code.toString(16).padStart(4, "0") + "_";
+    }
+  }
+  return result;
+}
+function unmangleKey(filename) {
+  let result = "";
+  let i = 0;
+  while (i < filename.length) {
+    if (filename[i] === "_") {
+      if (i + 5 < filename.length && filename[i + 5] === "_") {
+        const hex = filename.slice(i + 1, i + 5);
+        if (/^[0-9a-f]{4}$/i.test(hex)) {
+          result += String.fromCharCode(parseInt(hex, 16));
+          i += 6;
+          continue;
+        }
+      }
+      if (i + 3 < filename.length && filename[i + 3] === "_") {
+        const hex = filename.slice(i + 1, i + 3);
+        if (/^[0-9a-f]{2}$/i.test(hex)) {
+          result += String.fromCharCode(parseInt(hex, 16));
+          i += 4;
+          continue;
+        }
+      }
+      result += "_";
+      i++;
+    } else {
+      result += filename[i];
+      i++;
+    }
+  }
+  return result;
+}
+var FilesystemStorage = class _FilesystemStorage {
+  dirPath;
+  name;
+  resolvedDirPath = null;
+  initialized = false;
+  constructor(dirPath) {
+    this.dirPath = dirPath;
+    this.name = null;
+  }
+  static localShare(name) {
+    const s = new _FilesystemStorage("");
+    s.dirPath = null;
+    s.name = name;
+    return s;
+  }
+  async resolvedDir() {
+    if (!this.resolvedDirPath) {
+      if (this.dirPath) {
+        this.resolvedDirPath = this.dirPath;
+      } else {
+        const { os, path } = await getNodeDeps();
+        this.resolvedDirPath = path.join(os.homedir(), ".local", "share", this.name);
+      }
+    }
+    return this.resolvedDirPath;
+  }
+  async ensureDir() {
+    if (!this.initialized) {
+      const { fs } = await getNodeDeps();
+      await fs.mkdir(await this.resolvedDir(), { recursive: true });
+      this.initialized = true;
+    }
+  }
+  async filePath(key) {
+    const { path } = await getNodeDeps();
+    return path.join(await this.resolvedDir(), mangleKey(key));
+  }
+  async get(key) {
+    const { fs } = await getNodeDeps();
+    await this.ensureDir();
+    try {
+      return await fs.readFile(await this.filePath(key), "utf-8");
+    } catch (err) {
+      if (isNodeError(err) && err.code === "ENOENT") return null;
+      throw err;
+    }
+  }
+  async set(key, value) {
+    const { fs } = await getNodeDeps();
+    await this.ensureDir();
+    await fs.writeFile(await this.filePath(key), value, "utf-8");
+  }
+  async delete(key) {
+    const { fs } = await getNodeDeps();
+    await this.ensureDir();
+    try {
+      await fs.unlink(await this.filePath(key));
+    } catch (err) {
+      if (isNodeError(err) && err.code === "ENOENT") return;
+      throw err;
+    }
+  }
+  async keys(prefix) {
+    const { fs } = await getNodeDeps();
+    await this.ensureDir();
+    try {
+      const files = await fs.readdir(await this.resolvedDir());
+      return files.map(unmangleKey).filter((k) => k.startsWith(prefix)).sort();
+    } catch (err) {
+      if (isNodeError(err) && err.code === "ENOENT") return [];
+      throw err;
+    }
+  }
+  async getAll(prefix) {
+    const { fs } = await getNodeDeps();
+    await this.ensureDir();
+    try {
+      const files = await fs.readdir(await this.resolvedDir());
+      const keys = files.map(unmangleKey).filter((k) => k.startsWith(prefix));
+      const entries = await Promise.all(
+        keys.map(async (key) => {
+          const value = await this.get(key);
+          return value !== null ? [key, value] : null;
+        })
+      );
+      return entries.filter((e) => e !== null);
+    } catch (err) {
+      if (isNodeError(err) && err.code === "ENOENT") return [];
+      throw err;
+    }
+  }
+};
+
+// src/storage/locking.ts
+function isNodeError2(err) {
+  return err instanceof Error && "code" in err;
+}
+function addLocking(inner, name) {
+  let hasRealLock = false;
+  let overlay = null;
+  let releaseLock;
+  let lockRequestDone;
+  let lockPath = null;
+  let exitHandler = null;
+  let heartbeatTimer = null;
+  const STALE_MS = 3e4;
+  const HEARTBEAT_MS = 1e4;
+  async function tryAcquireReal() {
+    if (typeof navigator !== "undefined" && navigator.locks) {
+      let resolveAcquired;
+      const acquired = new Promise((r) => {
+        resolveAcquired = r;
+      });
+      lockRequestDone = navigator.locks.request(
+        `tor-js:${name}`,
+        { ifAvailable: true },
+        (lock) => {
+          if (lock) {
+            resolveAcquired(true);
+            return new Promise((r) => {
+              releaseLock = r;
+            });
+          }
+          resolveAcquired(false);
+        }
+      );
+      return acquired;
+    }
+    if (typeof process !== "undefined" && process.versions?.node) {
+      try {
+        const { fs, fsSync, path, os } = await getNodeDeps();
+        const dir = path.join(os.homedir(), ".local", "share", name);
+        await fs.mkdir(dir, { recursive: true });
+        const lp = path.join(dir, ".lock");
+        try {
+          await fs.writeFile(lp, `${process.pid}`, { flag: "wx" });
+        } catch (err) {
+          if (!isNodeError2(err) || err.code !== "EEXIST") throw err;
+          const stat = await fs.stat(lp);
+          if (Date.now() - stat.mtimeMs < STALE_MS) return false;
+          await fs.writeFile(lp, `${process.pid}`);
+        }
+        lockPath = lp;
+        heartbeatTimer = setInterval(async () => {
+          try {
+            const now = /* @__PURE__ */ new Date();
+            await fs.utimes(lp, now, now);
+          } catch {
+          }
+        }, HEARTBEAT_MS);
+        if (heartbeatTimer.unref) heartbeatTimer.unref();
+        exitHandler = () => {
+          try {
+            fsSync.unlinkSync(lp);
+          } catch {
+          }
+        };
+        process.on("exit", exitHandler);
+        return true;
+      } catch (err) {
+        return false;
+      }
+    }
+    throw new Error("Failed to detect suitable locking mechanism");
+  }
+  async function releaseReal() {
+    if (releaseLock) {
+      releaseLock();
+      releaseLock = void 0;
+      await lockRequestDone;
+      lockRequestDone = void 0;
+    }
+    if (heartbeatTimer) {
+      clearInterval(heartbeatTimer);
+      heartbeatTimer = null;
+    }
+    if (lockPath) {
+      const { fs } = await getNodeDeps();
+      try {
+        await fs.unlink(lockPath);
+      } catch (err) {
+        if (!isNodeError2(err) || err.code !== "ENOENT") throw err;
+      }
+      lockPath = null;
+    }
+    if (exitHandler) {
+      process.removeListener("exit", exitHandler);
+      exitHandler = null;
+    }
+  }
+  return {
+    async get(key) {
+      if (overlay?.has(key)) return overlay.get(key);
+      return inner.get(key);
+    },
+    async set(key, value) {
+      if (overlay) {
+        overlay.set(key, value);
+        return;
+      }
+      return inner.set(key, value);
+    },
+    async delete(key) {
+      if (overlay) {
+        overlay.set(key, null);
+        return;
+      }
+      return inner.delete(key);
+    },
+    async keys(prefix) {
+      const base = await inner.keys(prefix);
+      if (!overlay) return base;
+      const result = new Set(base);
+      for (const [k, v] of overlay) {
+        if (!k.startsWith(prefix)) continue;
+        if (v !== null) result.add(k);
+        else result.delete(k);
+      }
+      return [...result].sort();
+    },
+    async getAll(prefix) {
+      const base = await inner.getAll(prefix);
+      if (!overlay) return base;
+      const merged = new Map(base);
+      for (const [k, v] of overlay) {
+        if (!k.startsWith(prefix)) continue;
+        if (v !== null) merged.set(k, v);
+        else merged.delete(k);
+      }
+      return [...merged.entries()];
+    },
+    async tryLock() {
+      if (hasRealLock) return false;
+      const acquired = await tryAcquireReal();
+      hasRealLock = acquired;
+      overlay = acquired ? null : overlay ?? /* @__PURE__ */ new Map();
+      return true;
+    },
+    async unlock() {
+      await releaseReal();
+      hasRealLock = false;
+      overlay = null;
+    }
+  };
+}
+
+// src/storage/index.ts
+function createAutoStorage(name = "tor-js") {
+  if (typeof globalThis !== "undefined" && typeof globalThis.indexedDB !== "undefined") {
+    return addLocking(new IndexedDBStorage(name), name);
+  }
+  if (typeof process !== "undefined" && process.versions?.node) {
+    return addLocking(FilesystemStorage.localShare(name), name);
+  }
+  throw new Error(
+    "No persistent storage available: need IndexedDB (browser) or filesystem (Node.js)"
+  );
+}
+
+// src/socketProvider.ts
+var HAS_DENO = typeof globalThis.Deno !== "undefined";
+var HAS_NODE = typeof globalThis.process?.versions?.node !== "undefined";
+var HAS_RTC = typeof globalThis.RTCPeerConnection !== "undefined";
+var HAS_WS = typeof globalThis.WebSocket !== "undefined" || HAS_DENO || HAS_NODE;
+function defaultStrategies(hasUrl) {
+  const s = [];
+  if (HAS_DENO || HAS_NODE) s.push("direct");
+  if (hasUrl && HAS_RTC) s.push("webrtc");
+  if (hasUrl && HAS_WS) s.push("websocket");
+  return s;
+}
+var ArtiSocket = class _ArtiSocket {
+  #send;
+  #close;
+  #closed = false;
+  #onclose = null;
+  /** Set by transport on error, before onclose fires. */
+  _error = null;
+  /** Receive callback — transport fires this with each incoming chunk. */
+  onmessage = null;
+  constructor(send, close) {
+    this.#send = send;
+    this.#close = close;
+  }
+  /** Setter that fires immediately if close already happened. */
+  set onclose(fn) {
+    this.#onclose = fn;
+    if (this.#closed && fn) queueMicrotask(() => fn());
+  }
+  get onclose() {
+    return this.#onclose;
+  }
+  /** @internal — called by transport wrappers when the underlying connection closes. */
+  _notifyClose() {
+    if (this.#closed) return;
+    this.#closed = true;
+    this.#onclose?.();
+  }
+  send(data) {
+    this.#send(data);
+  }
+  close() {
+    this.#close();
+  }
+  // -- Transport factories --------------------------------------------------
+  /** Wrap a browser WebSocket (already open). */
+  static fromWebSocket(ws) {
+    const sock = new _ArtiSocket(
+      (data) => ws.send(data),
+      () => ws.close()
+    );
+    ws.onmessage = (ev) => sock.onmessage?.(new Uint8Array(ev.data));
+    ws.onclose = () => sock._notifyClose();
+    return sock;
+  }
+  /** Wrap a WebRTC data channel (already open). */
+  static fromDataChannel(dc) {
+    const sock = new _ArtiSocket(
+      (data) => dc.send(data),
+      () => dc.close()
+    );
+    dc.onmessage = (ev) => sock.onmessage?.(new Uint8Array(ev.data));
+    dc.onclose = () => sock._notifyClose();
+    return sock;
+  }
+  /** Wrap a Node.js net.Socket (already connected). */
+  static fromNodeSocket(socket) {
+    const sock = new _ArtiSocket(
+      (data) => socket.write(data),
+      () => socket.destroy()
+    );
+    socket.on("data", (buf) => sock.onmessage?.(new Uint8Array(buf)));
+    socket.on("close", () => sock._notifyClose());
+    socket.on("error", () => {
+    });
+    return sock;
+  }
+  /** Wrap a Deno TCP connection. */
+  static fromDenoConn(conn) {
+    const sock = new _ArtiSocket(
+      (data) => {
+        const writer = conn.writable.getWriter();
+        writer.write(data).then(() => writer.releaseLock());
+      },
+      () => conn.close()
+    );
+    (async () => {
+      try {
+        for await (const chunk of conn.readable) {
+          sock.onmessage?.(new Uint8Array(chunk));
+        }
+      } catch {
+      }
+      sock._notifyClose();
+    })();
+    return sock;
+  }
+};
+var ArtiSocketProvider = class {
+  #url;
+  #strategies;
+  // WebRTC state (lazily created, reused across connect() calls)
+  #rtcPc = null;
+  #rtcAlive = false;
+  #signalChannel = null;
+  // Tracked data channels: before open has reject, after open has sock.
+  #tracked = [];
+  constructor(options = {}) {
+    this.#url = options.gateway ? options.gateway.replace(/\/+$/, "") : null;
+    this.#strategies = options.strategies ?? defaultStrategies(!!this.#url);
+  }
+  /**
+   * Open a relay socket to the given target (e.g. "198.51.100.1:9001").
+   * Tries each configured strategy in order until one succeeds.
+   */
+  async connect(target) {
+    const errors = [];
+    for (const strategy of this.#strategies) {
+      try {
+        switch (strategy) {
+          case "direct":
+            return await this.#connectDirect(target);
+          case "webrtc":
+            return await this.#connectWebRTC(target);
+          case "websocket":
+            return await this.#connectWebSocket(target);
+          default:
+            throw new Error(`unknown strategy: ${strategy}`);
+        }
+      } catch (e) {
+        errors.push(`${strategy}: ${e.message}`);
+      }
+    }
+    throw new Error(`all strategies failed for ${target}: ${errors.join("; ")}`);
+  }
+  /** Close WebRTC peer connection and release resources. */
+  close() {
+    if (this.#rtcPc) {
+      this.#rtcPc.close();
+      this.#rtcPc = null;
+      this.#rtcAlive = false;
+      this.#signalChannel = null;
+    }
+  }
+  // -- Direct TCP strategy (Node.js / Deno) ---------------------------------
+  async #connectDirect(target) {
+    const [host, portStr] = target.split(":");
+    const port = parseInt(portStr, 10);
+    if (HAS_DENO) {
+      const conn = await globalThis.Deno.connect({ hostname: host, port });
+      return ArtiSocket.fromDenoConn(conn);
+    }
+    if (HAS_NODE) {
+      const net = await import("net");
+      const socket = net.createConnection({ host, port });
+      await new Promise((resolve, reject) => {
+        socket.once("connect", resolve);
+        socket.once("error", reject);
+      });
+      return ArtiSocket.fromNodeSocket(socket);
+    }
+    throw new Error("direct TCP not available in this environment");
+  }
+  // -- WebSocket strategy ---------------------------------------------------
+  async #connectWebSocket(target) {
+    if (!this.#url) throw new Error("websocket strategy requires a gateway URL");
+    const wsUrl = `${this.#url.replace(/^http/, "ws")}/socket/${target}`;
+    const ws = new WebSocket(wsUrl);
+    ws.binaryType = "arraybuffer";
+    await new Promise((resolve, reject) => {
+      ws.onopen = () => resolve();
+      ws.onerror = () => reject(new Error("websocket connection failed"));
+    });
+    return ArtiSocket.fromWebSocket(ws);
+  }
+  // -- WebRTC strategy ------------------------------------------------------
+  async #connectWebRTC(target) {
+    if (!this.#url) throw new Error("webrtc strategy requires a gateway URL");
+    if (typeof RTCPeerConnection === "undefined") {
+      throw new Error("RTCPeerConnection not available");
+    }
+    if (!this.#rtcAlive) {
+      if (this.#rtcPc) this.#rtcPc.close();
+      await this.#setupRtcPeerConnection();
+    }
+    const dc = this.#rtcPc.createDataChannel(target);
+    dc.binaryType = "arraybuffer";
+    const entry = { dc, sock: null, reject: null };
+    this.#tracked.push(entry);
+    await new Promise((resolve, reject) => {
+      entry.reject = reject;
+      dc.onopen = () => resolve();
+      dc.onerror = (e) => {
+        this.#removeTracked(entry);
+        reject(new Error(`data channel error: ${e.error?.message || e}`));
+      };
+    });
+    entry.reject = null;
+    const sock = ArtiSocket.fromDataChannel(dc);
+    entry.sock = sock;
+    dc.onclose = () => {
+      this.#removeTracked(entry);
+      sock._notifyClose();
+    };
+    return sock;
+  }
+  async #setupRtcPeerConnection() {
+    const pc = new RTCPeerConnection();
+    const signal = pc.createDataChannel("_signal");
+    signal.onmessage = (ev) => this.#handleSignalMessage(ev.data);
+    const offer = await pc.createOffer();
+    await pc.setLocalDescription(offer);
+    await new Promise((resolve) => {
+      if (pc.iceGatheringState === "complete") return resolve();
+      pc.addEventListener("icegatheringstatechange", () => {
+        if (pc.iceGatheringState === "complete") resolve();
+      });
+    });
+    const res = await fetch(`${this.#url}/rtc/connect`, {
+      method: "POST",
+      body: JSON.stringify(pc.localDescription)
+    });
+    if (!res.ok) {
+      pc.close();
+      throw new Error(`rtc signaling failed: ${res.status} ${await res.text()}`);
+    }
+    const answer = await res.json();
+    await pc.setRemoteDescription(answer);
+    await new Promise((resolve, reject) => {
+      if (pc.connectionState === "connected") return resolve();
+      pc.addEventListener("connectionstatechange", () => {
+        if (pc.connectionState === "connected") resolve();
+        if (pc.connectionState === "failed") reject(new Error("WebRTC connection failed"));
+      });
+    });
+    this.#rtcPc = pc;
+    this.#rtcAlive = true;
+    this.#signalChannel = signal;
+    pc.addEventListener("connectionstatechange", () => {
+      const s = pc.connectionState;
+      if (s === "disconnected" || s === "closed" || s === "failed") {
+        this.#rtcAlive = false;
+        this.#signalChannel = null;
+      }
+    });
+  }
+  #findTracked(sctpId, label) {
+    return this.#tracked.find((e) => e.dc.id != null && e.dc.id === sctpId) ?? this.#tracked.find((e) => e.dc.label === label);
+  }
+  #removeTracked(entry) {
+    const i = this.#tracked.indexOf(entry);
+    if (i !== -1) this.#tracked.splice(i, 1);
+  }
+  #handleSignalMessage(data) {
+    try {
+      const msg = JSON.parse(data);
+      switch (msg.type) {
+        case "rejected": {
+          const entry = this.#findTracked(msg.sctp_id, msg.channel);
+          if (entry) {
+            this.#removeTracked(entry);
+            if (entry.reject) {
+              entry.reject(new Error(`rejected: ${msg.reason}`));
+            } else if (entry.sock) {
+              entry.sock._error = msg.reason;
+              entry.sock.close();
+              entry.sock._notifyClose();
+            }
+          }
+          break;
+        }
+        case "closed": {
+          const entry = this.#findTracked(msg.sctp_id, msg.channel);
+          if (entry) {
+            this.#removeTracked(entry);
+            if (entry.sock) {
+              entry.sock.close();
+              entry.sock._notifyClose();
+            }
+          }
+          break;
+        }
+      }
+    } catch {
+    }
+  }
+};
+
+// src/TorClient.ts
+var TorClient2 = class {
+  log;
+  clientPromise;
+  removeLogListener = null;
+  wasmCallback = null;
+  closed = false;
+  readyPromise = null;
+  socketProvider = null;
+  constructor(options = {}) {
+    this.log = options.log ?? new Log({ rawLog: () => {
+    } });
+    this.clientPromise = this.bootstrap(options);
+  }
+  async bootstrap(options) {
+    await ensureWasmInitialized();
+    this.wasmCallback = this.log._makeWasmCallback();
+    this.removeLogListener = addLogListener(this.wasmCallback, options.logLevel);
+    this.socketProvider = options.socketProvider ?? new ArtiSocketProvider({ gateway: options.gateway });
+    const sp = this.socketProvider;
+    let wasmOptions = new TorClientOptions(
+      (addr) => sp.connect(addr)
+    );
+    const storage = options.storage ?? createAutoStorage();
+    wasmOptions = wasmOptions.withStorage(storage);
+    if (options.gateway) {
+      const gatewayBase = options.gateway.replace(/\/+$/, "");
+      wasmOptions = wasmOptions.withFastBootstrap(async () => {
+        this.log.info("Fast bootstrap: fetching bootstrap.zip.br...");
+        const res = await fetch(`${gatewayBase}/bootstrap.zip.br`);
+        if (!res.ok) {
+          throw new Error(`Fast bootstrap fetch failed: ${res.status} ${res.statusText}`);
+        }
+        const bytes = new Uint8Array(await res.arrayBuffer());
+        this.log.info(`Fast bootstrap: received ${bytes.byteLength} bytes`);
+        return bytes;
+      });
+    }
+    this.log.info("Bootstrapping...");
+    const client2 = await TorClient.create(wasmOptions);
+    this.log.info("Bootstrap complete");
+    return client2;
+  }
+  /**
+   * Make an HTTP fetch request through Tor.
+   * Returns a standard browser Response object.
+   */
+  async fetch(url, init2) {
+    if (this.closed) throw new Error("TorClient is closed");
+    const client2 = await this.clientPromise;
+    await this.ready();
+    this.log.info(`Fetching ${url}`);
+    return client2.fetch(url, init2);
+  }
+  /**
+   * Wait for the Tor client to be ready for traffic
+   * (guard connected, usable consensus, and sufficient microdescs).
+   *
+   * Parallel callers share the same underlying promise — a single WS
+   * connection failure rejects all waiters. The cached promise is cleared
+   * on settle so the next call creates a fresh attempt.
+   */
+  async ready() {
+    if (this.closed) throw new Error("TorClient is closed");
+    if (this.readyPromise) return this.readyPromise;
+    const p = (async () => {
+      const startTime = Date.now();
+      this.log.info("Waiting for client");
+      const client2 = await this.clientPromise;
+      this.log.info("Waiting for client to be ready");
+      await client2.ready();
+      this.log.info(`Client ready in ${Date.now() - startTime}ms`);
+    })();
+    this.readyPromise = p;
+    p.finally(() => {
+      this.readyPromise = null;
+    });
+    return p;
+  }
+  /**
+   * Change the log level for this client's listener.
+   * Also re-syncs the global WASM filter to the broadest level across all clients.
+   */
+  setLogLevel(level) {
+    if (this.wasmCallback) {
+      setListenerLevel(this.wasmCallback, level);
+    }
+  }
+  /**
+   * Close the TorClient and release resources.
+   */
+  close() {
+    if (this.closed) return;
+    this.closed = true;
+    this.removeLogListener?.();
+    this.removeLogListener = null;
+    this.wasmCallback = null;
+    this.socketProvider?.close();
+    this.socketProvider = null;
+    this.clientPromise.then((client2) => client2.close()).catch(() => {
+    });
+  }
+  [Symbol.dispose]() {
+    this.close();
+  }
+};
+
+// src/entryPoints/wasm-file/index.ts
+setWasmSourceProvider(async () => {
+  if (typeof process !== "undefined" && process.versions?.node) {
+    const { readFile } = await import("fs/promises");
+    const { fileURLToPath } = await import("url");
+    const wasmPath = fileURLToPath(new URL("./tor_js_bg.wasm", import.meta.url));
+    return readFile(wasmPath);
+  }
+  const resp = await fetch(new URL("./tor_js_bg.wasm", import.meta.url));
+  if (!resp.ok) throw new Error(`Failed to fetch WASM: HTTP ${resp.status}`);
+  return new Uint8Array(await resp.arrayBuffer());
+});
+
+// src/singleton.ts
+var client;
+var config = {
+  gateway: "https://tor-js-gateway.voltrevo.com"
+};
+var tor = {
+  /**
+   * Make an HTTP fetch request through Tor.
+   * Automatically opens the TorClient on first use.
+   */
+  async fetch(url, init2) {
+    if (!client) {
+      this.open();
+    }
+    return client.fetch(url, init2);
+  },
+  /**
+   * Configure the singleton TorClient.
+   * If already open, closes and reopens with the new config.
+   */
+  configure(options) {
+    config = options;
+    if (client) {
+      client.close();
+      client = void 0;
+      this.open();
+    }
+  },
+  /**
+   * Open the singleton TorClient.
+   * Optional — fetch() calls this automatically.
+   * Call this early if you know you'll need Tor, to start bootstrapping sooner.
+   */
+  open() {
+    if (client) return;
+    client = new TorClient2(config);
+  },
+  /**
+   * Close the singleton TorClient and release resources.
+   */
+  close() {
+    if (client) {
+      client.close();
+      client = void 0;
+    }
+  }
+};
+export {
+  ArtiSocket,
+  ArtiSocketProvider,
+  Log,
+  setWasmUrl,
+  storage_exports as storage,
+  tor
+};
+//# sourceMappingURL=singleton.js.map