@corpus-core/colibri-tor 1.1.22

package/node_modules/tor-js/dist/types.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"types.d.ts","sourceRoot":"","sources":["../src/types.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,GAAG,EAAE,MAAM,UAAU,CAAC;AACpC,OAAO,KAAK,EAAE,UAAU,EAAE,MAAM,OAAO,CAAC;AACxC,OAAO,KAAK,EAAE,kBAAkB,EAAE,MAAM,qBAAqB,CAAC;AAE9D,MAAM,MAAM,QAAQ,GAAG,OAAO,GAAG,OAAO,GAAG,MAAM,GAAG,MAAM,GAAG,OAAO,CAAC;AAErE;;;;;;GAMG;AACH,MAAM,MAAM,gBAAgB,GAAG;IAC7B,kKAAkK;IAClK,OAAO,CAAC,EAAE,MAAM,CAAC;IAEjB;;;;;;OAMG;IACH,GAAG,CAAC,EAAE,GAAG,CAAC;IAEV,qEAAqE;IACrE,OAAO,CAAC,EAAE,UAAU,CAAC;IAErB;;;;OAIG;IACH,QAAQ,CAAC,EAAE,QAAQ,CAAC;IAEpB,wHAAwH;IACxH,cAAc,CAAC,EAAE,kBAAkB,CAAC;CACrC,CAAC;AAEF,YAAY,EAAE,UAAU,EAAE,MAAM,OAAO,CAAC;AAExC,MAAM,WAAW,SAAS;IACxB,MAAM,CAAC,EAAE,MAAM,CAAC;IAChB,OAAO,CAAC,EAAE,MAAM,CAAC,MAAM,EAAE,MAAM,CAAC,CAAC;IACjC,IAAI,CAAC,EAAE,MAAM,GAAG,UAAU,GAAG,WAAW,CAAC;IACzC,MAAM,CAAC,EAAE,WAAW,CAAC;CACtB"}

package/node_modules/tor-js/dist/wasm-B6es-efC.d.ts

@@ -0,0 +1,302 @@
+type LogLevel$1 = 'trace' | 'debug' | 'info' | 'warn' | 'error';
+interface LogConstructorParams {
+    rawLog?: (level: LogLevel$1, ...args: unknown[]) => void;
+    parentStartTime?: number;
+    namePrefix?: string;
+}
+declare class Log {
+    private rawLog;
+    private parentStartTime;
+    private namePrefix;
+    constructor(params?: LogConstructorParams);
+    child(name: string): Log;
+    trace(...args: unknown[]): void;
+    debug(...args: unknown[]): void;
+    info(...args: unknown[]): void;
+    warn(...args: unknown[]): void;
+    error(...args: unknown[]): void;
+    /** @internal Create a callback for WASM setLogCallback */
+    _makeWasmCallback(): (level: string, target: string, message: string) => void;
+    private log;
+    private defaultRawLog;
+}
+
+/**
+ * Storage interface for persisting Tor client state.
+ *
+ * Implement this interface to provide custom storage (IndexedDB, filesystem, etc.).
+ * All methods must return Promises.
+ *
+ * When storage is provided, the Tor client will persist guard selection and other
+ * state, allowing faster reconnection across page reloads.
+ *
+ * @example
+ * ```typescript
+ * class IndexedDBStorage implements TorStorage {
+ *   async get(key: string): Promise<string | null> {
+ *     // Load from IndexedDB
+ *   }
+ *   async set(key: string, value: string): Promise<void> {
+ *     // Save to IndexedDB
+ *   }
+ *   async delete(key: string): Promise<void> {
+ *     // Delete from IndexedDB
+ *   }
+ *   async keys(prefix: string): Promise<string[]> {
+ *     // List keys matching prefix
+ *   }
+ *   async tryLock(): Promise<boolean> {
+ *     // addLocking is available in tor-js to solve locking with in-memory
+ *     // overlay
+ *     // true:   newly acquired
+ *     // false:  already held
+ *     // reject: couldn't lock
+ *   }
+ *   async unlock(): Promise<void> {
+ *   }
+ * }
+ *
+ * const options = new TorClientOptions(gatewayUrl)
+ *   .withStorage(new IndexedDBStorage());
+ * const client = await TorClient.create(options);
+ * ```
+ */
+interface TorStorage {
+    /**
+     * Get a value by key.
+     * @param key - The storage key
+     * @returns The stored value as a string, or null if not found
+     */
+    get(key: string): Promise<string | null>;
+
+    /**
+     * Get all key-value pairs matching a prefix.
+     * @param prefix - The key prefix to match
+     * @returns Array of [key, value] pairs
+     */
+    getAll(prefix: string): Promise<[string, string][]>;
+
+    /**
+     * Set a value by key.
+     * @param key - The storage key
+     * @param value - The value to store (JSON string)
+     */
+    set(key: string, value: string): Promise<void>;
+
+    /**
+     * Delete a value by key.
+     * @param key - The storage key
+     */
+    delete(key: string): Promise<void>;
+
+    /**
+     * List all keys with a given prefix.
+     * @param prefix - The key prefix to match
+     * @returns Array of matching keys
+     */
+    keys(prefix: string): Promise<string[]>;
+
+    /**
+     * Try to acquire an exclusive write lock.
+     * @returns true if newly acquired, false if already held.
+     * Implement using Web Locks API (browser) or lock files (Node.js).
+     */
+    tryLock(): Promise<boolean>;
+
+    /**
+     * Release the write lock.
+     */
+    unlock(): Promise<void>;
+}
+
+/**
+ * Socket provider for connecting to Tor relays via direct TCP, WebSocket,
+ * or WebRTC.
+ *
+ * ArtiSocketProvider auto-detects available strategies based on environment:
+ * - Node.js/Deno: tries direct TCP first, then WebSocket/WebRTC if a gateway URL is set
+ * - Browsers: tries WebRTC first (if available), then WebSocket (requires gateway URL)
+ *
+ * Each `connect(target)` call returns an {@link ArtiSocket} — a uniform
+ * bidirectional byte pipe regardless of transport.
+ */
+/**
+ * A bidirectional byte pipe to a Tor relay.
+ *
+ * Assign `onmessage` and `onclose` after creation.
+ * Call `send(data)` with Uint8Array and `close()` when done.
+ */
+declare class ArtiSocket {
+    #private;
+    /** Set by transport on error, before onclose fires. */
+    _error: string | null;
+    /** Receive callback — transport fires this with each incoming chunk. */
+    onmessage: ((data: Uint8Array) => void) | null;
+    constructor(send: (data: Uint8Array) => void, close: () => void);
+    /** Setter that fires immediately if close already happened. */
+    set onclose(fn: (() => void) | null);
+    get onclose(): (() => void) | null;
+    /** @internal — called by transport wrappers when the underlying connection closes. */
+    _notifyClose(): void;
+    send(data: Uint8Array): void;
+    close(): void;
+    /** Wrap a browser WebSocket (already open). */
+    static fromWebSocket(ws: WebSocket): ArtiSocket;
+    /** Wrap a WebRTC data channel (already open). */
+    static fromDataChannel(dc: RTCDataChannel): ArtiSocket;
+    /** Wrap a Node.js net.Socket (already connected). */
+    static fromNodeSocket(socket: any): ArtiSocket;
+    /** Wrap a Deno TCP connection. */
+    static fromDenoConn(conn: any): ArtiSocket;
+}
+/**
+ * Options for creating an ArtiSocketProvider.
+ */
+interface ArtiSocketProviderOptions {
+    /**
+     * Gateway URL (e.g., `"https://tor-js-gateway.example.com"`).
+     * Required in browsers for WebRTC/WebSocket relay connections.
+     * Optional in Node.js/Deno (enables fast bootstrap when provided).
+     */
+    gateway?: string;
+    /**
+     * Ordered list of strategies to try: `"direct"`, `"webrtc"`, `"websocket"`.
+     * Defaults based on environment and whether a gateway URL is provided.
+     */
+    strategies?: string[];
+}
+/**
+ * Opens sockets to Tor relays via configurable strategies (direct TCP,
+ * WebRTC data channels, WebSocket) with automatic fallback.
+ *
+ * The gateway URL is optional — without it, only the `direct` strategy is
+ * available (Node.js/Deno native TCP). With a gateway URL, WebRTC and
+ * WebSocket strategies become available for browser environments.
+ */
+declare class ArtiSocketProvider {
+    #private;
+    constructor(options?: ArtiSocketProviderOptions);
+    /**
+     * Open a relay socket to the given target (e.g. "198.51.100.1:9001").
+     * Tries each configured strategy in order until one succeeds.
+     */
+    connect(target: string): Promise<ArtiSocket>;
+    /** Close WebRTC peer connection and release resources. */
+    close(): void;
+}
+
+type LogLevel = 'trace' | 'debug' | 'info' | 'warn' | 'error';
+/**
+ * Options for creating a TorClient.
+ *
+ * In browsers, provide a gateway URL for WebSocket/WebRTC relay connections
+ * and fast bootstrap. In Node.js/Deno, the gateway connects via direct TCP
+ * without a URL; providing one enables fast bootstrap from that server.
+ */
+type TorClientOptions = {
+    /** Gateway URL (e.g., `"https://tor-js-gateway.voltrevo.com"`). Required in browsers for relay connections; optional in Node.js/Deno (enables fast bootstrap). */
+    gateway?: string;
+    /**
+     * Optional logger instance.
+     * Note: WASM logging is global, so all TorClient instances receive all WASM
+     * log events, not just their own. This is because wasm-bindgen generates a
+     * single module-level instance (`let wasm;`), so all Rust global state
+     * (including the tracing subscriber) is shared.
+     */
+    log?: Log;
+    /** Optional storage for persistent state (implements TorStorage). */
+    storage?: TorStorage;
+    /**
+     * Minimum log level for this client's log listener. Defaults to 'debug'.
+     * Can be changed at runtime via `TorClient.setLogLevel()`.
+     * The WASM subscriber auto-widens to the broadest level across all clients.
+     */
+    logLevel?: LogLevel;
+    /** Optional custom socket provider. When set, overrides the default ArtiSocketProvider created from the gateway URL. */
+    socketProvider?: ArtiSocketProvider;
+};
+
+interface FetchInit {
+    method?: string;
+    headers?: Record<string, string>;
+    body?: string | Uint8Array | ArrayBuffer;
+    signal?: AbortSignal;
+}
+
+declare class MemoryStorage implements TorStorage {
+    private data;
+    private locked;
+    get(key: string): Promise<string | null>;
+    set(key: string, value: string): Promise<void>;
+    delete(key: string): Promise<void>;
+    keys(prefix: string): Promise<string[]>;
+    getAll(prefix: string): Promise<[string, string][]>;
+    tryLock(): Promise<boolean>;
+    unlock(): Promise<void>;
+}
+
+/** Storage interface without locking — just the CRUD methods. */
+type TorStorageSimple = Omit<TorStorage, 'tryLock' | 'unlock'>;
+/**
+ * Wrap a simple storage with platform-detected locking.
+ *
+ * - Browser: Web Locks API (`navigator.locks`)
+ * - Node.js: lock file at `~/.local/share/${name}/.lock`
+ *
+ * If the real lock can't be acquired (another tab/process holds it),
+ * the wrapper degrades gracefully: reads fall through to the inner storage,
+ * writes go to an in-memory overlay, and `tryLock()` still returns `true`.
+ */
+declare function addLocking(inner: TorStorageSimple, name: string): TorStorage;
+
+declare class IndexedDBStorage implements TorStorageSimple {
+    private dbName;
+    private storeName;
+    private dbPromise;
+    constructor(name?: string);
+    private getDB;
+    get(key: string): Promise<string | null>;
+    set(key: string, value: string): Promise<void>;
+    delete(key: string): Promise<void>;
+    keys(prefix: string): Promise<string[]>;
+    getAll(prefix: string): Promise<[string, string][]>;
+}
+
+declare class FilesystemStorage implements TorStorageSimple {
+    private dirPath;
+    private name;
+    private resolvedDirPath;
+    private initialized;
+    constructor(dirPath: string);
+    static localShare(name: string): FilesystemStorage;
+    private resolvedDir;
+    private ensureDir;
+    private filePath;
+    get(key: string): Promise<string | null>;
+    set(key: string, value: string): Promise<void>;
+    delete(key: string): Promise<void>;
+    keys(prefix: string): Promise<string[]>;
+    getAll(prefix: string): Promise<[string, string][]>;
+}
+
+declare function createAutoStorage(name?: string): TorStorage;
+
+type index_FilesystemStorage = FilesystemStorage;
+declare const index_FilesystemStorage: typeof FilesystemStorage;
+type index_IndexedDBStorage = IndexedDBStorage;
+declare const index_IndexedDBStorage: typeof IndexedDBStorage;
+type index_MemoryStorage = MemoryStorage;
+declare const index_MemoryStorage: typeof MemoryStorage;
+type index_TorStorageSimple = TorStorageSimple;
+declare const index_addLocking: typeof addLocking;
+declare const index_createAutoStorage: typeof createAutoStorage;
+declare namespace index {
+  export { index_FilesystemStorage as FilesystemStorage, index_IndexedDBStorage as IndexedDBStorage, index_MemoryStorage as MemoryStorage, type index_TorStorageSimple as TorStorageSimple, index_addLocking as addLocking, index_createAutoStorage as createAutoStorage };
+}
+
+/**
+ * Override the WASM binary URL. Must be called before any TorClient is created.
+ */
+declare function setWasmUrl(url: string | URL): void;
+
+export { ArtiSocket as A, type FetchInit as F, type LogLevel as L, type TorClientOptions as T, ArtiSocketProvider as a, type ArtiSocketProviderOptions as b, Log as c, type LogLevel$1 as d, type TorStorage as e, index as i, setWasmUrl as s };

package/node_modules/tor-js/dist/wasm-pkg/tor_js.d.ts

@@ -0,0 +1,311 @@
+/* tslint:disable */
+/* eslint-disable */
+/**
+ * The `ReadableStreamType` enum.
+ *
+ * *This API requires the following crate features to be activated: `ReadableStreamType`*
+ */
+
+type ReadableStreamType = "bytes";
+
+/**
+ * Storage interface for persisting Tor client state.
+ *
+ * Implement this interface to provide custom storage (IndexedDB, filesystem, etc.).
+ * All methods must return Promises.
+ *
+ * When storage is provided, the Tor client will persist guard selection and other
+ * state, allowing faster reconnection across page reloads.
+ *
+ * @example
+ * ```typescript
+ * class IndexedDBStorage implements TorStorage {
+ *   async get(key: string): Promise<string | null> {
+ *     // Load from IndexedDB
+ *   }
+ *   async set(key: string, value: string): Promise<void> {
+ *     // Save to IndexedDB
+ *   }
+ *   async delete(key: string): Promise<void> {
+ *     // Delete from IndexedDB
+ *   }
+ *   async keys(prefix: string): Promise<string[]> {
+ *     // List keys matching prefix
+ *   }
+ *   async tryLock(): Promise<boolean> {
+ *     // addLocking is available in tor-js to solve locking with in-memory
+ *     // overlay
+ *     // true:   newly acquired
+ *     // false:  already held
+ *     // reject: couldn't lock
+ *   }
+ *   async unlock(): Promise<void> {
+ *   }
+ * }
+ *
+ * const options = new TorClientOptions(gatewayUrl)
+ *   .withStorage(new IndexedDBStorage());
+ * const client = await TorClient.create(options);
+ * ```
+ */
+export interface TorStorage {
+    /**
+     * Get a value by key.
+     * @param key - The storage key
+     * @returns The stored value as a string, or null if not found
+     */
+    get(key: string): Promise<string | null>;
+
+    /**
+     * Get all key-value pairs matching a prefix.
+     * @param prefix - The key prefix to match
+     * @returns Array of [key, value] pairs
+     */
+    getAll(prefix: string): Promise<[string, string][]>;
+
+    /**
+     * Set a value by key.
+     * @param key - The storage key
+     * @param value - The value to store (JSON string)
+     */
+    set(key: string, value: string): Promise<void>;
+
+    /**
+     * Delete a value by key.
+     * @param key - The storage key
+     */
+    delete(key: string): Promise<void>;
+
+    /**
+     * List all keys with a given prefix.
+     * @param prefix - The key prefix to match
+     * @returns Array of matching keys
+     */
+    keys(prefix: string): Promise<string[]>;
+
+    /**
+     * Try to acquire an exclusive write lock.
+     * @returns true if newly acquired, false if already held.
+     * Implement using Web Locks API (browser) or lock files (Node.js).
+     */
+    tryLock(): Promise<boolean>;
+
+    /**
+     * Release the write lock.
+     */
+    unlock(): Promise<void>;
+}
+
+export interface FetchInit {
+    method?: string;
+    headers?: Record<string, string>;
+    body?: string | Uint8Array | ArrayBuffer;
+    signal?: AbortSignal;
+}
+
+export interface TorClient {
+    /** Make an HTTP fetch request through Tor. Returns a standard Response. */
+    fetch(url: string, init?: FetchInit): Promise<Response>;
+    close(): Promise<void>;
+}
+
+export interface TorClientOptions {
+    /**
+     * Set a custom storage implementation for persistent state.
+     * If not provided, in-memory storage is used (state lost on page reload).
+     */
+    withStorage(storage: TorStorage): TorClientOptions;
+}
+
+
+
+export class IntoUnderlyingByteSource {
+    private constructor();
+    free(): void;
+    [Symbol.dispose](): void;
+    cancel(): void;
+    pull(controller: ReadableByteStreamController): Promise<any>;
+    start(controller: ReadableByteStreamController): void;
+    readonly autoAllocateChunkSize: number;
+    readonly type: ReadableStreamType;
+}
+
+export class IntoUnderlyingSink {
+    private constructor();
+    free(): void;
+    [Symbol.dispose](): void;
+    abort(reason: any): Promise<any>;
+    close(): Promise<any>;
+    write(chunk: any): Promise<any>;
+}
+
+export class IntoUnderlyingSource {
+    private constructor();
+    free(): void;
+    [Symbol.dispose](): void;
+    cancel(): void;
+    pull(controller: ReadableStreamDefaultController): Promise<any>;
+}
+
+/**
+ * Tor client for making HTTP requests through the Tor network
+ */
+export class TorClient {
+    private constructor();
+    free(): void;
+    [Symbol.dispose](): void;
+    /**
+     * Close the TorClient and release resources
+     */
+    close(): Promise<any>;
+    /**
+     * 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);`
+     */
+    static create(options: TorClientOptions): Promise<any>;
+    /**
+     * Wait until the client is ready for traffic (connection usable + valid directory).
+     */
+    ready(): Promise<any>;
+}
+
+/**
+ * Options for creating a TorClient
+ */
+export class TorClientOptions {
+    free(): void;
+    [Symbol.dispose](): void;
+    /**
+     * 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.
+     */
+    constructor(connect: Function);
+    /**
+     * 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.
+     */
+    withFastBootstrap(callback: Function): TorClientOptions;
+    /**
+     * 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
+     */
+    withStorage(storage: TorStorage): TorClientOptions;
+}
+
+/**
+ * Initialize the tor-js WASM module
+ *
+ * This must be called before creating any TorClient instances.
+ * Sets up panic hooks and logging infrastructure.
+ *
+ * The optional `log_level` parameter sets the initial log level:
+ * "trace", "debug", "info", "warn", or "error". Defaults to "debug".
+ * The level can be changed later with `setLogLevel()`.
+ */
+export function init(log_level?: string | null): void;
+
+/**
+ * Set a callback function to receive log messages
+ *
+ * The callback receives three arguments: (level: string, target: string, message: string)
+ */
+export function setLogCallback(callback: Function): void;
+
+/**
+ * Dynamically update the minimum log level.
+ *
+ * Called from JS when the broadest requested level across all clients changes.
+ */
+export function setLogLevel(level: string): void;
+
+export type InitInput = RequestInfo | URL | Response | BufferSource | WebAssembly.Module;
+
+export interface InitOutput {
+    readonly memory: WebAssembly.Memory;
+    readonly __wbg_torclient_free: (a: number, b: number) => void;
+    readonly __wbg_torclientoptions_free: (a: number, b: number) => void;
+    readonly init: (a: number, b: number) => [number, number];
+    readonly setLogLevel: (a: number, b: number) => [number, number];
+    readonly torclient_close: (a: number) => any;
+    readonly torclient_create: (a: number) => any;
+    readonly torclient_fetch: (a: number, b: number, c: number, d: any) => any;
+    readonly torclient_ready: (a: number) => any;
+    readonly torclientoptions_new: (a: any) => number;
+    readonly torclientoptions_withFastBootstrap: (a: number, b: any) => number;
+    readonly torclientoptions_withStorage: (a: number, b: any) => number;
+    readonly setLogCallback: (a: any) => void;
+    readonly __wbg_intounderlyingbytesource_free: (a: number, b: number) => void;
+    readonly __wbg_intounderlyingsink_free: (a: number, b: number) => void;
+    readonly __wbg_intounderlyingsource_free: (a: number, b: number) => void;
+    readonly intounderlyingbytesource_autoAllocateChunkSize: (a: number) => number;
+    readonly intounderlyingbytesource_cancel: (a: number) => void;
+    readonly intounderlyingbytesource_pull: (a: number, b: any) => any;
+    readonly intounderlyingbytesource_start: (a: number, b: any) => void;
+    readonly intounderlyingbytesource_type: (a: number) => number;
+    readonly intounderlyingsink_abort: (a: number, b: any) => any;
+    readonly intounderlyingsink_close: (a: number) => any;
+    readonly intounderlyingsink_write: (a: number, b: any) => any;
+    readonly intounderlyingsource_cancel: (a: number) => void;
+    readonly intounderlyingsource_pull: (a: number, b: any) => any;
+    readonly wasm_bindgen__closure__destroy__h9b79478a56146cd2: (a: number, b: number) => void;
+    readonly wasm_bindgen__closure__destroy__h4d8dd6cb42c8a695: (a: number, b: number) => void;
+    readonly wasm_bindgen__closure__destroy__h1e3ac41672e7b2ad: (a: number, b: number) => void;
+    readonly wasm_bindgen__convert__closures_____invoke__hc2bcdd2c6020290d: (a: number, b: number, c: any) => [number, number];
+    readonly wasm_bindgen__convert__closures_____invoke__hb864778e5a95f086: (a: number, b: number, c: any, d: any) => void;
+    readonly wasm_bindgen__convert__closures_____invoke__h5c591e637e5094b1: (a: number, b: number, c: any) => void;
+    readonly wasm_bindgen__convert__closures_____invoke__h69c112f8841b438b: (a: number, b: number) => void;
+    readonly __wbindgen_malloc: (a: number, b: number) => number;
+    readonly __wbindgen_realloc: (a: number, b: number, c: number, d: number) => number;
+    readonly __wbindgen_exn_store: (a: number) => void;
+    readonly __externref_table_alloc: () => number;
+    readonly __wbindgen_externrefs: WebAssembly.Table;
+    readonly __wbindgen_free: (a: number, b: number, c: number) => void;
+    readonly __externref_table_dealloc: (a: number) => void;
+    readonly __wbindgen_start: () => void;
+}
+
+export type SyncInitInput = BufferSource | WebAssembly.Module;
+
+/**
+ * Instantiates the given `module`, which can either be bytes or
+ * a precompiled `WebAssembly.Module`.
+ *
+ * @param {{ module: SyncInitInput }} module - Passing `SyncInitInput` directly is deprecated.
+ *
+ * @returns {InitOutput}
+ */
+export function initSync(module: { module: SyncInitInput } | SyncInitInput): InitOutput;
+
+/**
+ * If `module_or_path` is {RequestInfo} or {URL}, makes a request and
+ * for everything else, calls `WebAssembly.instantiate` directly.
+ *
+ * @param {{ module_or_path: InitInput | Promise<InitInput> }} module_or_path - Passing `InitInput` directly is deprecated.
+ *
+ * @returns {Promise<InitOutput>}
+ */
+export default function __wbg_init (module_or_path?: { module_or_path: InitInput | Promise<InitInput> } | InitInput | Promise<InitInput>): Promise<InitOutput>;