@ruvector/attention-wasm 2.0.4 → 2.2.0

package/ruvector_attention_wasm.d.ts

@@ -1,252 +1,285 @@
 /* tslint:disable */
 /* eslint-disable */
 
+/**
+ * Adam optimizer
+ */
 export class WasmAdam {
-  free(): void;
-  [Symbol.dispose](): void;
-  /**
-   * Create a new Adam optimizer
-   *
-   * # Arguments
-   * * `param_count` - Number of parameters
-   * * `learning_rate` - Learning rate
-   */
-  constructor(param_count: number, learning_rate: number);
-  /**
-   * Perform optimization step
-   *
-   * # Arguments
-   * * `params` - Current parameter values (will be updated in-place)
-   * * `gradients` - Gradient values
-   */
-  step(params: Float32Array, gradients: Float32Array): void;
-  /**
-   * Reset optimizer state
-   */
-  reset(): void;
-  /**
-   * Get current learning rate
-   */
-  learning_rate: number;
+    free(): void;
+    [Symbol.dispose](): void;
+    /**
+     * Create a new Adam optimizer
+     *
+     * # Arguments
+     * * `param_count` - Number of parameters
+     * * `learning_rate` - Learning rate
+     */
+    constructor(param_count: number, learning_rate: number);
+    /**
+     * Reset optimizer state
+     */
+    reset(): void;
+    /**
+     * Perform optimization step
+     *
+     * # Arguments
+     * * `params` - Current parameter values (will be updated in-place)
+     * * `gradients` - Gradient values
+     */
+    step(params: Float32Array, gradients: Float32Array): void;
+    /**
+     * Get current learning rate
+     */
+    learning_rate: number;
 }
 
+/**
+ * AdamW optimizer (Adam with decoupled weight decay)
+ */
 export class WasmAdamW {
-  free(): void;
-  [Symbol.dispose](): void;
-  /**
-   * Create a new AdamW optimizer
-   *
-   * # Arguments
-   * * `param_count` - Number of parameters
-   * * `learning_rate` - Learning rate
-   * * `weight_decay` - Weight decay coefficient
-   */
-  constructor(param_count: number, learning_rate: number, weight_decay: number);
-  /**
-   * Perform optimization step with weight decay
-   */
-  step(params: Float32Array, gradients: Float32Array): void;
-  /**
-   * Reset optimizer state
-   */
-  reset(): void;
-  /**
-   * Get weight decay
-   */
-  readonly weight_decay: number;
-  /**
-   * Get current learning rate
-   */
-  learning_rate: number;
+    free(): void;
+    [Symbol.dispose](): void;
+    /**
+     * Create a new AdamW optimizer
+     *
+     * # Arguments
+     * * `param_count` - Number of parameters
+     * * `learning_rate` - Learning rate
+     * * `weight_decay` - Weight decay coefficient
+     */
+    constructor(param_count: number, learning_rate: number, weight_decay: number);
+    /**
+     * Reset optimizer state
+     */
+    reset(): void;
+    /**
+     * Perform optimization step with weight decay
+     */
+    step(params: Float32Array, gradients: Float32Array): void;
+    /**
+     * Get current learning rate
+     */
+    learning_rate: number;
+    /**
+     * Get weight decay
+     */
+    readonly weight_decay: number;
 }
 
+/**
+ * Flash attention mechanism
+ */
 export class WasmFlashAttention {
-  free(): void;
-  [Symbol.dispose](): void;
-  /**
-   * Create a new flash attention instance
-   *
-   * # Arguments
-   * * `dim` - Embedding dimension
-   * * `block_size` - Block size for tiling
-   */
-  constructor(dim: number, block_size: number);
-  /**
-   * Compute flash attention
-   */
-  compute(query: Float32Array, keys: any, values: any): Float32Array;
+    free(): void;
+    [Symbol.dispose](): void;
+    /**
+     * Compute flash attention
+     */
+    compute(query: Float32Array, keys: any, values: any): Float32Array;
+    /**
+     * Create a new flash attention instance
+     *
+     * # Arguments
+     * * `dim` - Embedding dimension
+     * * `block_size` - Block size for tiling
+     */
+    constructor(dim: number, block_size: number);
 }
 
+/**
+ * Hyperbolic attention mechanism
+ */
 export class WasmHyperbolicAttention {
-  free(): void;
-  [Symbol.dispose](): void;
-  /**
-   * Create a new hyperbolic attention instance
-   *
-   * # Arguments
-   * * `dim` - Embedding dimension
-   * * `curvature` - Hyperbolic curvature parameter
-   */
-  constructor(dim: number, curvature: number);
-  /**
-   * Compute hyperbolic attention
-   */
-  compute(query: Float32Array, keys: any, values: any): Float32Array;
-  /**
-   * Get the curvature
-   */
-  readonly curvature: number;
+    free(): void;
+    [Symbol.dispose](): void;
+    /**
+     * Compute hyperbolic attention
+     */
+    compute(query: Float32Array, keys: any, values: any): Float32Array;
+    /**
+     * Create a new hyperbolic attention instance
+     *
+     * # Arguments
+     * * `dim` - Embedding dimension
+     * * `curvature` - Hyperbolic curvature parameter
+     */
+    constructor(dim: number, curvature: number);
+    /**
+     * Get the curvature
+     */
+    readonly curvature: number;
 }
 
+/**
+ * InfoNCE contrastive loss for training
+ */
 export class WasmInfoNCELoss {
-  free(): void;
-  [Symbol.dispose](): void;
-  /**
-   * Create a new InfoNCE loss instance
-   *
-   * # Arguments
-   * * `temperature` - Temperature parameter for softmax
-   */
-  constructor(temperature: number);
-  /**
-   * Compute InfoNCE loss
-   *
-   * # Arguments
-   * * `anchor` - Anchor embedding
-   * * `positive` - Positive example embedding
-   * * `negatives` - Array of negative example embeddings
-   */
-  compute(anchor: Float32Array, positive: Float32Array, negatives: any): number;
+    free(): void;
+    [Symbol.dispose](): void;
+    /**
+     * Compute InfoNCE loss
+     *
+     * # Arguments
+     * * `anchor` - Anchor embedding
+     * * `positive` - Positive example embedding
+     * * `negatives` - Array of negative example embeddings
+     */
+    compute(anchor: Float32Array, positive: Float32Array, negatives: any): number;
+    /**
+     * Create a new InfoNCE loss instance
+     *
+     * # Arguments
+     * * `temperature` - Temperature parameter for softmax
+     */
+    constructor(temperature: number);
 }
 
+/**
+ * Learning rate scheduler
+ */
 export class WasmLRScheduler {
-  free(): void;
-  [Symbol.dispose](): void;
-  /**
-   * Create a new learning rate scheduler with warmup and cosine decay
-   *
-   * # Arguments
-   * * `initial_lr` - Initial learning rate
-   * * `warmup_steps` - Number of warmup steps
-   * * `total_steps` - Total training steps
-   */
-  constructor(initial_lr: number, warmup_steps: number, total_steps: number);
-  /**
-   * Advance to next step
-   */
-  step(): void;
-  /**
-   * Reset scheduler
-   */
-  reset(): void;
-  /**
-   * Get learning rate for current step
-   */
-  get_lr(): number;
+    free(): void;
+    [Symbol.dispose](): void;
+    /**
+     * Get learning rate for current step
+     */
+    get_lr(): number;
+    /**
+     * Create a new learning rate scheduler with warmup and cosine decay
+     *
+     * # Arguments
+     * * `initial_lr` - Initial learning rate
+     * * `warmup_steps` - Number of warmup steps
+     * * `total_steps` - Total training steps
+     */
+    constructor(initial_lr: number, warmup_steps: number, total_steps: number);
+    /**
+     * Reset scheduler
+     */
+    reset(): void;
+    /**
+     * Advance to next step
+     */
+    step(): void;
 }
 
+/**
+ * Linear attention (Performer-style)
+ */
 export class WasmLinearAttention {
-  free(): void;
-  [Symbol.dispose](): void;
-  /**
-   * Create a new linear attention instance
-   *
-   * # Arguments
-   * * `dim` - Embedding dimension
-   * * `num_features` - Number of random features
-   */
-  constructor(dim: number, num_features: number);
-  /**
-   * Compute linear attention
-   */
-  compute(query: Float32Array, keys: any, values: any): Float32Array;
+    free(): void;
+    [Symbol.dispose](): void;
+    /**
+     * Compute linear attention
+     */
+    compute(query: Float32Array, keys: any, values: any): Float32Array;
+    /**
+     * Create a new linear attention instance
+     *
+     * # Arguments
+     * * `dim` - Embedding dimension
+     * * `num_features` - Number of random features
+     */
+    constructor(dim: number, num_features: number);
 }
 
+/**
+ * Local-global attention mechanism
+ */
 export class WasmLocalGlobalAttention {
-  free(): void;
-  [Symbol.dispose](): void;
-  /**
-   * Create a new local-global attention instance
-   *
-   * # Arguments
-   * * `dim` - Embedding dimension
-   * * `local_window` - Size of local attention window
-   * * `global_tokens` - Number of global attention tokens
-   */
-  constructor(dim: number, local_window: number, global_tokens: number);
-  /**
-   * Compute local-global attention
-   */
-  compute(query: Float32Array, keys: any, values: any): Float32Array;
+    free(): void;
+    [Symbol.dispose](): void;
+    /**
+     * Compute local-global attention
+     */
+    compute(query: Float32Array, keys: any, values: any): Float32Array;
+    /**
+     * Create a new local-global attention instance
+     *
+     * # Arguments
+     * * `dim` - Embedding dimension
+     * * `local_window` - Size of local attention window
+     * * `global_tokens` - Number of global attention tokens
+     */
+    constructor(dim: number, local_window: number, global_tokens: number);
 }
 
+/**
+ * Mixture of Experts (MoE) attention
+ */
 export class WasmMoEAttention {
-  free(): void;
-  [Symbol.dispose](): void;
-  /**
-   * Create a new MoE attention instance
-   *
-   * # Arguments
-   * * `dim` - Embedding dimension
-   * * `num_experts` - Number of expert attention mechanisms
-   * * `top_k` - Number of experts to use per query
-   */
-  constructor(dim: number, num_experts: number, top_k: number);
-  /**
-   * Compute MoE attention
-   */
-  compute(query: Float32Array, keys: any, values: any): Float32Array;
+    free(): void;
+    [Symbol.dispose](): void;
+    /**
+     * Compute MoE attention
+     */
+    compute(query: Float32Array, keys: any, values: any): Float32Array;
+    /**
+     * Create a new MoE attention instance
+     *
+     * # Arguments
+     * * `dim` - Embedding dimension
+     * * `num_experts` - Number of expert attention mechanisms
+     * * `top_k` - Number of experts to use per query
+     */
+    constructor(dim: number, num_experts: number, top_k: number);
 }
 
+/**
+ * Multi-head attention mechanism
+ */
 export class WasmMultiHeadAttention {
-  free(): void;
-  [Symbol.dispose](): void;
-  /**
-   * Create a new multi-head attention instance
-   *
-   * # Arguments
-   * * `dim` - Embedding dimension
-   * * `num_heads` - Number of attention heads
-   */
-  constructor(dim: number, num_heads: number);
-  /**
-   * Compute multi-head attention
-   */
-  compute(query: Float32Array, keys: any, values: any): Float32Array;
-  /**
-   * Get the dimension
-   */
-  readonly dim: number;
-  /**
-   * Get the number of heads
-   */
-  readonly num_heads: number;
+    free(): void;
+    [Symbol.dispose](): void;
+    /**
+     * Compute multi-head attention
+     */
+    compute(query: Float32Array, keys: any, values: any): Float32Array;
+    /**
+     * Create a new multi-head attention instance
+     *
+     * # Arguments
+     * * `dim` - Embedding dimension
+     * * `num_heads` - Number of attention heads
+     */
+    constructor(dim: number, num_heads: number);
+    /**
+     * Get the dimension
+     */
+    readonly dim: number;
+    /**
+     * Get the number of heads
+     */
+    readonly num_heads: number;
 }
 
+/**
+ * SGD optimizer with momentum
+ */
 export class WasmSGD {
-  free(): void;
-  [Symbol.dispose](): void;
-  /**
-   * Create a new SGD optimizer
-   *
-   * # Arguments
-   * * `param_count` - Number of parameters
-   * * `learning_rate` - Learning rate
-   * * `momentum` - Momentum coefficient (default: 0)
-   */
-  constructor(param_count: number, learning_rate: number, momentum?: number | null);
-  /**
-   * Perform optimization step
-   */
-  step(params: Float32Array, gradients: Float32Array): void;
-  /**
-   * Reset optimizer state
-   */
-  reset(): void;
-  /**
-   * Get current learning rate
-   */
-  learning_rate: number;
+    free(): void;
+    [Symbol.dispose](): void;
+    /**
+     * Create a new SGD optimizer
+     *
+     * # Arguments
+     * * `param_count` - Number of parameters
+     * * `learning_rate` - Learning rate
+     * * `momentum` - Momentum coefficient (default: 0)
+     */
+    constructor(param_count: number, learning_rate: number, momentum?: number | null);
+    /**
+     * Reset optimizer state
+     */
+    reset(): void;
+    /**
+     * Perform optimization step
+     */
+    step(params: Float32Array, gradients: Float32Array): void;
+    /**
+     * Get current learning rate
+     */
+    learning_rate: number;
 }
 
 /**
@@ -328,95 +361,95 @@ export function version(): string;
 export type InitInput = RequestInfo | URL | Response | BufferSource | WebAssembly.Module;
 
 export interface InitOutput {
-  readonly memory: WebAssembly.Memory;
-  readonly __wbg_wasmadam_free: (a: number, b: number) => void;
-  readonly __wbg_wasmadamw_free: (a: number, b: number) => void;
-  readonly __wbg_wasmflashattention_free: (a: number, b: number) => void;
-  readonly __wbg_wasmhyperbolicattention_free: (a: number, b: number) => void;
-  readonly __wbg_wasminfonceloss_free: (a: number, b: number) => void;
-  readonly __wbg_wasmlinearattention_free: (a: number, b: number) => void;
-  readonly __wbg_wasmmoeattention_free: (a: number, b: number) => void;
-  readonly __wbg_wasmmultiheadattention_free: (a: number, b: number) => void;
-  readonly __wbg_wasmsgd_free: (a: number, b: number) => void;
-  readonly attention_weights: (a: number, b: number, c: number, d: number) => void;
-  readonly available_mechanisms: () => number;
-  readonly batch_normalize: (a: number, b: number, c: number) => void;
-  readonly cosine_similarity: (a: number, b: number, c: number, d: number, e: number) => void;
-  readonly l2_norm: (a: number, b: number) => number;
-  readonly log: (a: number, b: number) => void;
-  readonly log_error: (a: number, b: number) => void;
-  readonly normalize: (a: number, b: number, c: number, d: number) => void;
-  readonly pairwise_distances: (a: number, b: number) => void;
-  readonly random_orthogonal_matrix: (a: number, b: number) => void;
-  readonly scaled_dot_attention: (a: number, b: number, c: number, d: number, e: number, f: number) => void;
-  readonly softmax: (a: number, b: number, c: number) => void;
-  readonly version: (a: number) => void;
-  readonly wasmadam_learning_rate: (a: number) => number;
-  readonly wasmadam_new: (a: number, b: number) => number;
-  readonly wasmadam_reset: (a: number) => void;
-  readonly wasmadam_set_learning_rate: (a: number, b: number) => void;
-  readonly wasmadam_step: (a: number, b: number, c: number, d: number, e: number, f: number) => void;
-  readonly wasmadamw_new: (a: number, b: number, c: number) => number;
-  readonly wasmadamw_reset: (a: number) => void;
-  readonly wasmadamw_step: (a: number, b: number, c: number, d: number, e: number, f: number) => void;
-  readonly wasmadamw_weight_decay: (a: number) => number;
-  readonly wasmflashattention_compute: (a: number, b: number, c: number, d: number, e: number, f: number) => void;
-  readonly wasmflashattention_new: (a: number, b: number) => number;
-  readonly wasmhyperbolicattention_compute: (a: number, b: number, c: number, d: number, e: number, f: number) => void;
-  readonly wasmhyperbolicattention_curvature: (a: number) => number;
-  readonly wasmhyperbolicattention_new: (a: number, b: number) => number;
-  readonly wasminfonceloss_compute: (a: number, b: number, c: number, d: number, e: number, f: number, g: number) => void;
-  readonly wasminfonceloss_new: (a: number) => number;
-  readonly wasmlinearattention_compute: (a: number, b: number, c: number, d: number, e: number, f: number) => void;
-  readonly wasmlinearattention_new: (a: number, b: number) => number;
-  readonly wasmlocalglobalattention_compute: (a: number, b: number, c: number, d: number, e: number, f: number) => void;
-  readonly wasmlocalglobalattention_new: (a: number, b: number, c: number) => number;
-  readonly wasmlrscheduler_get_lr: (a: number) => number;
-  readonly wasmlrscheduler_new: (a: number, b: number, c: number) => number;
-  readonly wasmlrscheduler_reset: (a: number) => void;
-  readonly wasmlrscheduler_step: (a: number) => void;
-  readonly wasmmoeattention_compute: (a: number, b: number, c: number, d: number, e: number, f: number) => void;
-  readonly wasmmoeattention_new: (a: number, b: number, c: number) => number;
-  readonly wasmmultiheadattention_compute: (a: number, b: number, c: number, d: number, e: number, f: number) => void;
-  readonly wasmmultiheadattention_dim: (a: number) => number;
-  readonly wasmmultiheadattention_new: (a: number, b: number, c: number) => void;
-  readonly wasmmultiheadattention_num_heads: (a: number) => number;
-  readonly wasmsgd_learning_rate: (a: number) => number;
-  readonly wasmsgd_new: (a: number, b: number, c: number) => number;
-  readonly wasmsgd_reset: (a: number) => void;
-  readonly wasmsgd_set_learning_rate: (a: number, b: number) => void;
-  readonly wasmsgd_step: (a: number, b: number, c: number, d: number, e: number, f: number) => void;
-  readonly init: () => void;
-  readonly wasmadamw_set_learning_rate: (a: number, b: number) => void;
-  readonly wasmadamw_learning_rate: (a: number) => number;
-  readonly __wbg_wasmlocalglobalattention_free: (a: number, b: number) => void;
-  readonly __wbg_wasmlrscheduler_free: (a: number, b: number) => void;
-  readonly __wbindgen_export: (a: number, b: number) => number;
-  readonly __wbindgen_export2: (a: number, b: number, c: number, d: number) => number;
-  readonly __wbindgen_export3: (a: number) => void;
-  readonly __wbindgen_export4: (a: number, b: number, c: number) => void;
-  readonly __wbindgen_add_to_stack_pointer: (a: number) => number;
-  readonly __wbindgen_start: () => void;
+    readonly memory: WebAssembly.Memory;
+    readonly __wbg_wasmadam_free: (a: number, b: number) => void;
+    readonly __wbg_wasmadamw_free: (a: number, b: number) => void;
+    readonly __wbg_wasmflashattention_free: (a: number, b: number) => void;
+    readonly __wbg_wasmhyperbolicattention_free: (a: number, b: number) => void;
+    readonly __wbg_wasminfonceloss_free: (a: number, b: number) => void;
+    readonly __wbg_wasmlinearattention_free: (a: number, b: number) => void;
+    readonly __wbg_wasmmoeattention_free: (a: number, b: number) => void;
+    readonly __wbg_wasmmultiheadattention_free: (a: number, b: number) => void;
+    readonly __wbg_wasmsgd_free: (a: number, b: number) => void;
+    readonly attention_weights: (a: number, b: number, c: number, d: number) => void;
+    readonly available_mechanisms: () => number;
+    readonly batch_normalize: (a: number, b: number, c: number) => void;
+    readonly cosine_similarity: (a: number, b: number, c: number, d: number, e: number) => void;
+    readonly l2_norm: (a: number, b: number) => number;
+    readonly log: (a: number, b: number) => void;
+    readonly log_error: (a: number, b: number) => void;
+    readonly normalize: (a: number, b: number, c: number, d: number) => void;
+    readonly pairwise_distances: (a: number, b: number) => void;
+    readonly random_orthogonal_matrix: (a: number, b: number) => void;
+    readonly scaled_dot_attention: (a: number, b: number, c: number, d: number, e: number, f: number) => void;
+    readonly softmax: (a: number, b: number, c: number) => void;
+    readonly version: (a: number) => void;
+    readonly wasmadam_learning_rate: (a: number) => number;
+    readonly wasmadam_new: (a: number, b: number) => number;
+    readonly wasmadam_reset: (a: number) => void;
+    readonly wasmadam_set_learning_rate: (a: number, b: number) => void;
+    readonly wasmadam_step: (a: number, b: number, c: number, d: number, e: number, f: number) => void;
+    readonly wasmadamw_new: (a: number, b: number, c: number) => number;
+    readonly wasmadamw_reset: (a: number) => void;
+    readonly wasmadamw_step: (a: number, b: number, c: number, d: number, e: number, f: number) => void;
+    readonly wasmadamw_weight_decay: (a: number) => number;
+    readonly wasmflashattention_compute: (a: number, b: number, c: number, d: number, e: number, f: number) => void;
+    readonly wasmflashattention_new: (a: number, b: number) => number;
+    readonly wasmhyperbolicattention_compute: (a: number, b: number, c: number, d: number, e: number, f: number) => void;
+    readonly wasmhyperbolicattention_curvature: (a: number) => number;
+    readonly wasmhyperbolicattention_new: (a: number, b: number) => number;
+    readonly wasminfonceloss_compute: (a: number, b: number, c: number, d: number, e: number, f: number, g: number) => void;
+    readonly wasminfonceloss_new: (a: number) => number;
+    readonly wasmlinearattention_compute: (a: number, b: number, c: number, d: number, e: number, f: number) => void;
+    readonly wasmlinearattention_new: (a: number, b: number) => number;
+    readonly wasmlocalglobalattention_compute: (a: number, b: number, c: number, d: number, e: number, f: number) => void;
+    readonly wasmlocalglobalattention_new: (a: number, b: number, c: number) => number;
+    readonly wasmlrscheduler_get_lr: (a: number) => number;
+    readonly wasmlrscheduler_new: (a: number, b: number, c: number) => number;
+    readonly wasmlrscheduler_reset: (a: number) => void;
+    readonly wasmlrscheduler_step: (a: number) => void;
+    readonly wasmmoeattention_compute: (a: number, b: number, c: number, d: number, e: number, f: number) => void;
+    readonly wasmmoeattention_new: (a: number, b: number, c: number) => number;
+    readonly wasmmultiheadattention_compute: (a: number, b: number, c: number, d: number, e: number, f: number) => void;
+    readonly wasmmultiheadattention_dim: (a: number) => number;
+    readonly wasmmultiheadattention_new: (a: number, b: number, c: number) => void;
+    readonly wasmmultiheadattention_num_heads: (a: number) => number;
+    readonly wasmsgd_learning_rate: (a: number) => number;
+    readonly wasmsgd_new: (a: number, b: number, c: number) => number;
+    readonly wasmsgd_reset: (a: number) => void;
+    readonly wasmsgd_set_learning_rate: (a: number, b: number) => void;
+    readonly wasmsgd_step: (a: number, b: number, c: number, d: number, e: number, f: number) => void;
+    readonly init: () => void;
+    readonly wasmadamw_set_learning_rate: (a: number, b: number) => void;
+    readonly wasmadamw_learning_rate: (a: number) => number;
+    readonly __wbg_wasmlocalglobalattention_free: (a: number, b: number) => void;
+    readonly __wbg_wasmlrscheduler_free: (a: number, b: number) => void;
+    readonly __wbindgen_export: (a: number, b: number) => number;
+    readonly __wbindgen_export2: (a: number, b: number, c: number, d: number) => number;
+    readonly __wbindgen_export3: (a: number) => void;
+    readonly __wbindgen_export4: (a: number, b: number, c: number) => void;
+    readonly __wbindgen_add_to_stack_pointer: (a: number) => number;
+    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}
-*/
+ * 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>}
-*/
+ * 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>;