open-ultrahdr-wasm 0.1.0 → 0.1.2

package/package.json

@@ -1,6 +1,6 @@
 {
 	"name": "open-ultrahdr-wasm",
-	"version": "0.1.0",
+	"version": "0.1.2",
 	"description": "UltraHDR (ISO 21496-1) gain map WASM implementation",
 	"author": "Adam Silverstein",
 	"license": "GPL-2.0-or-later",
@@ -15,7 +15,7 @@
 	"homepage": "https://github.com/adamsilverstein/lib-open-ultrahdr",
 	"repository": {
 		"type": "git",
-		"url": "https://github.com/adamsilverstein/lib-open-ultrahdr.git",
+		"url": "git+https://github.com/adamsilverstein/lib-open-ultrahdr.git",
 		"directory": "wasm"
 	},
 	"bugs": {

package/pkg/README.md

@@ -0,0 +1,17 @@
+# Open UltraHDR WASM
+
+WebAssembly module for UltraHDR (ISO 21496-1) gain map implementation.
+
+This is the low-level WASM package. For most use cases, use the `open-ultrahdr` package instead, which provides a higher-level TypeScript API.
+
+## Building
+
+Requires Rust and wasm-pack:
+
+```bash
+npm run build
+```
+
+## License
+
+GPL-2.0-or-later

package/pkg/open_ultrahdr.d.ts

@@ -0,0 +1,591 @@
+/* tslint:disable */
+/* eslint-disable */
+
+/**
+ * Color gamut enumeration for HDR images.
+ */
+export enum ColorGamut {
+    /**
+     * Standard sRGB color space (BT.709 primaries)
+     */
+    Srgb = 0,
+    /**
+     * Display P3 wide color gamut
+     */
+    DisplayP3 = 1,
+    /**
+     * BT.2100/BT.2020 wide color gamut (HDR)
+     */
+    Bt2100 = 2,
+}
+
+/**
+ * ISO 21496-1 Gain Map Metadata.
+ *
+ * This structure contains all the metadata required to interpret and apply
+ * a gain map according to the ISO 21496-1 specification.
+ */
+export class GainMapMetadata {
+    free(): void;
+    [Symbol.dispose](): void;
+    /**
+     * Creates metadata suitable for a typical SDR base with HDR gain map.
+     */
+    static forSdrBase(hdr_capacity_max: number): GainMapMetadata;
+    /**
+     * Creates a new GainMapMetadata with default values.
+     */
+    constructor();
+    /**
+     * Whether the base rendition is HDR (false = SDR base, true = HDR base)
+     */
+    baseRenditionIsHdr: boolean;
+    /**
+     * Maximum gain value per channel (RGB), in log2 scale
+     */
+    gainMapMax: Float32Array;
+    /**
+     * Minimum gain value per channel (RGB), in log2 scale
+     */
+    gainMapMin: Float32Array;
+    /**
+     * Gamma correction per channel (RGB)
+     */
+    gamma: Float32Array;
+    /**
+     * Maximum HDR capacity (log2 scale) for full HDR output
+     */
+    hdrCapacityMax: number;
+    /**
+     * Minimum HDR capacity (log2 scale) where gain map starts to apply
+     */
+    hdrCapacityMin: number;
+    /**
+     * HDR offset per channel (RGB), used for black point adjustment
+     */
+    offsetHdr: Float32Array;
+    /**
+     * SDR offset per channel (RGB), used for black point adjustment
+     */
+    offsetSdr: Float32Array;
+    /**
+     * Specification version (e.g., "1.0")
+     */
+    version: string;
+}
+
+/**
+ * Transfer function for encoding luminance.
+ */
+export enum TransferFunction {
+    /**
+     * sRGB transfer function (gamma ~2.2)
+     */
+    Srgb = 0,
+    /**
+     * Linear (no gamma)
+     */
+    Linear = 1,
+    /**
+     * Perceptual Quantizer (PQ) - SMPTE ST 2084
+     */
+    Pq = 2,
+    /**
+     * Hybrid Log-Gamma (HLG) - BT.2100
+     */
+    Hlg = 3,
+}
+
+/**
+ * Result of decoding an UltraHDR image.
+ */
+export class UltraHdrDecodeResult {
+    free(): void;
+    [Symbol.dispose](): void;
+    /**
+     * Creates a new decode result.
+     */
+    constructor(sdr_image: Uint8Array, gain_map: Uint8Array, metadata: GainMapMetadata, width: number, height: number, gain_map_width: number, gain_map_height: number);
+    /**
+     * Gain map height in pixels (may differ from image height)
+     */
+    gainMapHeight: number;
+    /**
+     * Gain map width in pixels (may differ from image width)
+     */
+    gainMapWidth: number;
+    /**
+     * The gain map as grayscale JPEG bytes
+     */
+    gainMap: Uint8Array;
+    /**
+     * Image height in pixels
+     */
+    height: number;
+    /**
+     * Gain map metadata
+     */
+    metadata: GainMapMetadata;
+    /**
+     * The SDR base image as JPEG bytes
+     */
+    sdrImage: Uint8Array;
+    /**
+     * Image width in pixels
+     */
+    width: number;
+}
+
+/**
+ * Options for encoding UltraHDR images.
+ */
+export class UltraHdrEncodeOptions {
+    free(): void;
+    [Symbol.dispose](): void;
+    /**
+     * Creates options optimized for high quality output.
+     */
+    static highQuality(): UltraHdrEncodeOptions;
+    /**
+     * Creates encoding options with default values.
+     */
+    constructor();
+    /**
+     * Creates options optimized for smaller file size.
+     */
+    static smallSize(): UltraHdrEncodeOptions;
+    /**
+     * JPEG quality for the base image (1-100)
+     */
+    baseQuality: number;
+    /**
+     * JPEG quality for the gain map (1-100)
+     */
+    gainMapQuality: number;
+    /**
+     * Downscale factor for the gain map (1 = same size, 2 = half, 4 = quarter)
+     */
+    gainMapScale: number;
+    /**
+     * Whether to include ISO 21496-1 metadata
+     */
+    includeIsoMetadata: boolean;
+    /**
+     * Whether to include UltraHDR v1 metadata for Android compatibility
+     */
+    includeUltrahdrV1: boolean;
+    /**
+     * Target HDR capacity (typically 2.0-4.0)
+     */
+    targetHdrCapacity: number;
+}
+
+/**
+ * Result of probing an image to check if it's UltraHDR.
+ *
+ * This provides detailed information about what components were found
+ * without fully decoding the image. Useful for batch processing and filtering.
+ */
+export class UltraHdrProbeResult {
+    free(): void;
+    [Symbol.dispose](): void;
+    /**
+     * Creates a new probe result with default (invalid) values.
+     */
+    constructor();
+    /**
+     * Gain map height in pixels (0 if not found)
+     */
+    gainMapHeight: number;
+    /**
+     * Gain map width in pixels (0 if not found)
+     */
+    gainMapWidth: number;
+    /**
+     * Whether a gain map image was found
+     */
+    hasGainMap: boolean;
+    /**
+     * Whether gain map metadata (XMP) was found
+     */
+    hasMetadata: boolean;
+    /**
+     * Whether a primary JPEG image was found
+     */
+    hasPrimaryImage: boolean;
+    /**
+     * HDR capacity (max additional stops of dynamic range), 0 if not found
+     */
+    hdrCapacity: number;
+    /**
+     * Primary image height in pixels (0 if not found)
+     */
+    height: number;
+    /**
+     * Whether the image is a valid UltraHDR image (has all required components)
+     */
+    isValid: boolean;
+    /**
+     * Metadata version string (empty if not found)
+     */
+    metadataVersion: string;
+    /**
+     * Primary image width in pixels (0 if not found)
+     */
+    width: number;
+}
+
+/**
+ * Creates default gain map metadata.
+ *
+ * Useful for testing or when creating metadata programmatically.
+ */
+export function createDefaultMetadata(): GainMapMetadata;
+
+/**
+ * Creates default encoding options.
+ *
+ * # Returns
+ * `UltraHdrEncodeOptions` with sensible defaults:
+ * - baseQuality: 85
+ * - gainMapQuality: 75
+ * - targetHdrCapacity: 3.0
+ * - includeIsoMetadata: true
+ * - includeUltrahdrV1: true
+ * - gainMapScale: 1
+ */
+export function createDefaultOptions(): UltraHdrEncodeOptions;
+
+/**
+ * Creates high quality encoding options.
+ *
+ * # Returns
+ * `UltraHdrEncodeOptions` optimized for quality:
+ * - baseQuality: 95
+ * - gainMapQuality: 85
+ * - targetHdrCapacity: 4.0
+ */
+export function createHighQualityOptions(): UltraHdrEncodeOptions;
+
+/**
+ * Creates small size encoding options.
+ *
+ * # Returns
+ * `UltraHdrEncodeOptions` optimized for file size:
+ * - baseQuality: 75
+ * - gainMapQuality: 65
+ * - targetHdrCapacity: 3.0
+ * - gainMapScale: 2 (half-size gain map)
+ */
+export function createSmallSizeOptions(): UltraHdrEncodeOptions;
+
+/**
+ * Decodes an UltraHDR JPEG, extracting SDR base, gain map, and metadata.
+ *
+ * # Arguments
+ * * `buffer` - UltraHDR JPEG file contents as bytes
+ *
+ * # Returns
+ * A `UltraHdrDecodeResult` containing:
+ * - `sdrImage`: The SDR base image as JPEG bytes
+ * - `gainMap`: The gain map as JPEG bytes
+ * - `metadata`: Gain map metadata (version, gains, gamma, offsets, etc.)
+ * - `width`, `height`: Image dimensions
+ * - `gainMapWidth`, `gainMapHeight`: Gain map dimensions
+ *
+ * # Errors
+ * Returns an error if the buffer is not a valid UltraHDR JPEG.
+ */
+export function decodeUltraHdr(buffer: Uint8Array): UltraHdrDecodeResult;
+
+/**
+ * Encodes an UltraHDR JPEG from SDR and HDR inputs.
+ *
+ * # Arguments
+ * * `sdr_buffer` - SDR JPEG image bytes
+ * * `hdr_buffer` - HDR image as linear RGB float32 array (3 values per pixel, normalized to [0,1])
+ * * `options` - Encoding options (quality, HDR capacity, etc.)
+ *
+ * # Returns
+ * The encoded UltraHDR JPEG as bytes.
+ *
+ * # Errors
+ * Returns an error if:
+ * - The SDR buffer is not a valid JPEG
+ * - The HDR buffer size doesn't match the SDR dimensions
+ * - The dimensions are invalid (e.g., odd width/height)
+ *
+ * # Example (JavaScript)
+ * ```js
+ * const options = new UltraHdrEncodeOptions();
+ * options.baseQuality = 90;
+ * options.targetHdrCapacity = 3.0;
+ *
+ * const sdrBuffer = await sdrFile.arrayBuffer();
+ * const hdrBuffer = await getHdrLinearData(); // Float32Array
+ *
+ * const ultraHdr = encodeUltraHdr(
+ *     new Uint8Array(sdrBuffer),
+ *     new Float32Array(hdrBuffer),
+ *     options
+ * );
+ * ```
+ */
+export function encodeUltraHdr(sdr_buffer: Uint8Array, hdr_buffer: Float32Array, options: UltraHdrEncodeOptions): Uint8Array;
+
+/**
+ * Estimates the HDR headroom from metadata.
+ *
+ * # Arguments
+ * * `metadata` - The gain map metadata
+ *
+ * # Returns
+ * The maximum additional stops of dynamic range above SDR.
+ */
+export function estimateHdrHeadroom(metadata: GainMapMetadata): number;
+
+/**
+ * Extracts just the SDR base image from an UltraHDR JPEG.
+ *
+ * This produces a standard JPEG that can be displayed on any device,
+ * without the gain map metadata. Useful for backwards compatibility.
+ *
+ * # Arguments
+ * * `buffer` - UltraHDR JPEG file contents as bytes
+ *
+ * # Returns
+ * A standard JPEG without gain map metadata.
+ *
+ * # Errors
+ * Returns an error if the buffer is not a valid JPEG.
+ */
+export function extractSdrBase(buffer: Uint8Array): Uint8Array;
+
+/**
+ * Gets gain map metadata from an UltraHDR JPEG without full decode.
+ *
+ * This is faster than `decodeUltraHdr` when you only need the metadata.
+ *
+ * # Arguments
+ * * `buffer` - UltraHDR JPEG file contents as bytes
+ *
+ * # Returns
+ * The gain map metadata.
+ *
+ * # Errors
+ * Returns an error if the buffer doesn't contain gain map metadata.
+ */
+export function getMetadata(buffer: Uint8Array): GainMapMetadata;
+
+/**
+ * Initializes the WASM module.
+ *
+ * This should be called before using any other functions.
+ */
+export function init(): void;
+
+/**
+ * Checks if metadata indicates a meaningful HDR image.
+ *
+ * # Arguments
+ * * `metadata` - The gain map metadata
+ *
+ * # Returns
+ * `true` if the gain map provides significant dynamic range extension
+ * (more than half a stop).
+ */
+export function isMeaningfulHdr(metadata: GainMapMetadata): boolean;
+
+/**
+ * Checks if a JPEG buffer contains UltraHDR/gain map data.
+ *
+ * This is a fast check that looks for gain map metadata in the XMP
+ * or MPF segments without fully decoding the image.
+ *
+ * # Arguments
+ * * `buffer` - JPEG file contents as bytes
+ *
+ * # Returns
+ * `true` if the image contains gain map metadata, `false` otherwise
+ *
+ * # Example (JavaScript)
+ * ```js
+ * const buffer = await file.arrayBuffer();
+ * const isHdr = isUltraHdr(new Uint8Array(buffer));
+ * ```
+ */
+export function isUltraHdr(buffer: Uint8Array): boolean;
+
+/**
+ * Probes an image to check if it's UltraHDR and extracts component information.
+ *
+ * This function efficiently validates if an image is UltraHDR by checking for
+ * required components (primary image, gain map, metadata) without full decoding.
+ * Returns structured results useful for batch processing and filtering.
+ *
+ * Unlike `isUltraHdr`, this function provides detailed information about what
+ * was found, making it useful for diagnostics and filtering workflows.
+ *
+ * # Arguments
+ * * `buffer` - Image file contents as bytes
+ *
+ * # Returns
+ * `UltraHdrProbeResult` containing:
+ * - `isValid`: Whether the image is a valid UltraHDR image
+ * - `hasPrimaryImage`: Whether a primary JPEG was found
+ * - `hasGainMap`: Whether a gain map image was found
+ * - `hasMetadata`: Whether XMP metadata was found
+ * - `width`, `height`: Primary image dimensions (0 if not found)
+ * - `gainMapWidth`, `gainMapHeight`: Gain map dimensions (0 if not found)
+ * - `hdrCapacity`: HDR capacity in stops (0 if not found)
+ * - `metadataVersion`: Metadata version string (empty if not found)
+ *
+ * # Example (JavaScript)
+ * ```js
+ * const buffer = await file.arrayBuffer();
+ * const result = probeUltraHdr(new Uint8Array(buffer));
+ * if (result.isValid) {
+ *     console.log('UltraHDR image:', result.width, 'x', result.height);
+ *     console.log('HDR capacity:', result.hdrCapacity, 'stops');
+ * } else {
+ *     if (!result.hasPrimaryImage) console.log('Not a JPEG');
+ *     if (!result.hasGainMap) console.log('No gain map found');
+ *     if (!result.hasMetadata) console.log('No HDR metadata');
+ * }
+ * ```
+ */
+export function probeUltraHdr(buffer: Uint8Array): UltraHdrProbeResult;
+
+/**
+ * Validates gain map metadata.
+ *
+ * # Arguments
+ * * `metadata` - The metadata to validate
+ *
+ * # Returns
+ * `true` if the metadata is valid, `false` otherwise
+ */
+export function validateMetadata(metadata: GainMapMetadata): boolean;
+
+export type InitInput = RequestInfo | URL | Response | BufferSource | WebAssembly.Module;
+
+export interface InitOutput {
+    readonly memory: WebAssembly.Memory;
+    readonly __wbg_gainmapmetadata_free: (a: number, b: number) => void;
+    readonly __wbg_get_gainmapmetadata_baseRenditionIsHdr: (a: number) => number;
+    readonly __wbg_get_gainmapmetadata_gainMapMax: (a: number) => [number, number];
+    readonly __wbg_get_gainmapmetadata_gainMapMin: (a: number) => [number, number];
+    readonly __wbg_get_gainmapmetadata_gamma: (a: number) => [number, number];
+    readonly __wbg_get_gainmapmetadata_hdrCapacityMax: (a: number) => number;
+    readonly __wbg_get_gainmapmetadata_hdrCapacityMin: (a: number) => number;
+    readonly __wbg_get_gainmapmetadata_offsetHdr: (a: number) => [number, number];
+    readonly __wbg_get_gainmapmetadata_offsetSdr: (a: number) => [number, number];
+    readonly __wbg_get_gainmapmetadata_version: (a: number) => [number, number];
+    readonly __wbg_get_ultrahdrdecoderesult_gainMap: (a: number) => [number, number];
+    readonly __wbg_get_ultrahdrdecoderesult_gainMapHeight: (a: number) => number;
+    readonly __wbg_get_ultrahdrdecoderesult_gainMapWidth: (a: number) => number;
+    readonly __wbg_get_ultrahdrdecoderesult_height: (a: number) => number;
+    readonly __wbg_get_ultrahdrdecoderesult_metadata: (a: number) => number;
+    readonly __wbg_get_ultrahdrdecoderesult_sdrImage: (a: number) => [number, number];
+    readonly __wbg_get_ultrahdrdecoderesult_width: (a: number) => number;
+    readonly __wbg_get_ultrahdrencodeoptions_baseQuality: (a: number) => number;
+    readonly __wbg_get_ultrahdrencodeoptions_gainMapQuality: (a: number) => number;
+    readonly __wbg_get_ultrahdrencodeoptions_gainMapScale: (a: number) => number;
+    readonly __wbg_get_ultrahdrencodeoptions_includeIsoMetadata: (a: number) => number;
+    readonly __wbg_get_ultrahdrencodeoptions_includeUltrahdrV1: (a: number) => number;
+    readonly __wbg_get_ultrahdrencodeoptions_targetHdrCapacity: (a: number) => number;
+    readonly __wbg_get_ultrahdrproberesult_gainMapHeight: (a: number) => number;
+    readonly __wbg_get_ultrahdrproberesult_gainMapWidth: (a: number) => number;
+    readonly __wbg_get_ultrahdrproberesult_hasGainMap: (a: number) => number;
+    readonly __wbg_get_ultrahdrproberesult_hasMetadata: (a: number) => number;
+    readonly __wbg_get_ultrahdrproberesult_hasPrimaryImage: (a: number) => number;
+    readonly __wbg_get_ultrahdrproberesult_hdrCapacity: (a: number) => number;
+    readonly __wbg_get_ultrahdrproberesult_height: (a: number) => number;
+    readonly __wbg_get_ultrahdrproberesult_isValid: (a: number) => number;
+    readonly __wbg_get_ultrahdrproberesult_width: (a: number) => number;
+    readonly __wbg_set_gainmapmetadata_baseRenditionIsHdr: (a: number, b: number) => void;
+    readonly __wbg_set_gainmapmetadata_gainMapMax: (a: number, b: number, c: number) => void;
+    readonly __wbg_set_gainmapmetadata_gainMapMin: (a: number, b: number, c: number) => void;
+    readonly __wbg_set_gainmapmetadata_gamma: (a: number, b: number, c: number) => void;
+    readonly __wbg_set_gainmapmetadata_hdrCapacityMax: (a: number, b: number) => void;
+    readonly __wbg_set_gainmapmetadata_hdrCapacityMin: (a: number, b: number) => void;
+    readonly __wbg_set_gainmapmetadata_offsetHdr: (a: number, b: number, c: number) => void;
+    readonly __wbg_set_gainmapmetadata_offsetSdr: (a: number, b: number, c: number) => void;
+    readonly __wbg_set_gainmapmetadata_version: (a: number, b: number, c: number) => void;
+    readonly __wbg_set_ultrahdrdecoderesult_gainMap: (a: number, b: number, c: number) => void;
+    readonly __wbg_set_ultrahdrdecoderesult_gainMapHeight: (a: number, b: number) => void;
+    readonly __wbg_set_ultrahdrdecoderesult_gainMapWidth: (a: number, b: number) => void;
+    readonly __wbg_set_ultrahdrdecoderesult_height: (a: number, b: number) => void;
+    readonly __wbg_set_ultrahdrdecoderesult_metadata: (a: number, b: number) => void;
+    readonly __wbg_set_ultrahdrdecoderesult_width: (a: number, b: number) => void;
+    readonly __wbg_set_ultrahdrencodeoptions_baseQuality: (a: number, b: number) => void;
+    readonly __wbg_set_ultrahdrencodeoptions_gainMapQuality: (a: number, b: number) => void;
+    readonly __wbg_set_ultrahdrencodeoptions_gainMapScale: (a: number, b: number) => void;
+    readonly __wbg_set_ultrahdrencodeoptions_includeIsoMetadata: (a: number, b: number) => void;
+    readonly __wbg_set_ultrahdrencodeoptions_includeUltrahdrV1: (a: number, b: number) => void;
+    readonly __wbg_set_ultrahdrencodeoptions_targetHdrCapacity: (a: number, b: number) => void;
+    readonly __wbg_set_ultrahdrproberesult_gainMapHeight: (a: number, b: number) => void;
+    readonly __wbg_set_ultrahdrproberesult_gainMapWidth: (a: number, b: number) => void;
+    readonly __wbg_set_ultrahdrproberesult_hasGainMap: (a: number, b: number) => void;
+    readonly __wbg_set_ultrahdrproberesult_hasMetadata: (a: number, b: number) => void;
+    readonly __wbg_set_ultrahdrproberesult_hasPrimaryImage: (a: number, b: number) => void;
+    readonly __wbg_set_ultrahdrproberesult_hdrCapacity: (a: number, b: number) => void;
+    readonly __wbg_set_ultrahdrproberesult_height: (a: number, b: number) => void;
+    readonly __wbg_set_ultrahdrproberesult_isValid: (a: number, b: number) => void;
+    readonly __wbg_set_ultrahdrproberesult_width: (a: number, b: number) => void;
+    readonly __wbg_ultrahdrdecoderesult_free: (a: number, b: number) => void;
+    readonly __wbg_ultrahdrencodeoptions_free: (a: number, b: number) => void;
+    readonly __wbg_ultrahdrproberesult_free: (a: number, b: number) => void;
+    readonly gainmapmetadata_forSdrBase: (a: number) => number;
+    readonly gainmapmetadata_new: () => number;
+    readonly ultrahdrdecoderesult_new: (a: number, b: number, c: number, d: number, e: number, f: number, g: number, h: number, i: number) => number;
+    readonly ultrahdrencodeoptions_highQuality: () => number;
+    readonly ultrahdrencodeoptions_new: () => number;
+    readonly ultrahdrencodeoptions_smallSize: () => number;
+    readonly ultrahdrproberesult_new: () => number;
+    readonly __wbg_get_ultrahdrproberesult_metadataVersion: (a: number) => [number, number];
+    readonly __wbg_set_ultrahdrdecoderesult_sdrImage: (a: number, b: number, c: number) => void;
+    readonly __wbg_set_ultrahdrproberesult_metadataVersion: (a: number, b: number, c: number) => void;
+    readonly createDefaultMetadata: () => number;
+    readonly createDefaultOptions: () => number;
+    readonly createHighQualityOptions: () => number;
+    readonly createSmallSizeOptions: () => number;
+    readonly decodeUltraHdr: (a: number, b: number) => [number, number, number];
+    readonly encodeUltraHdr: (a: number, b: number, c: number, d: number, e: number) => [number, number, number, number];
+    readonly estimateHdrHeadroom: (a: number) => number;
+    readonly extractSdrBase: (a: number, b: number) => [number, number, number, number];
+    readonly getMetadata: (a: number, b: number) => [number, number, number];
+    readonly init: () => void;
+    readonly isMeaningfulHdr: (a: number) => number;
+    readonly isUltraHdr: (a: number, b: number) => number;
+    readonly probeUltraHdr: (a: number, b: number) => number;
+    readonly validateMetadata: (a: number) => number;
+    readonly __wbindgen_externrefs: WebAssembly.Table;
+    readonly __wbindgen_malloc: (a: number, b: number) => number;
+    readonly __externref_table_dealloc: (a: number) => void;
+    readonly __wbindgen_free: (a: number, b: number, c: number) => void;
+    readonly __wbindgen_realloc: (a: number, b: number, c: number, d: 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}
+ */
+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>;