open-ultrahdr-wasm 0.1.1 → 0.2.0

package/README.md

@@ -1,17 +1,24 @@
 # Open UltraHDR WASM
 
-WebAssembly module for UltraHDR (ISO 21496-1) gain map implementation.
+WebAssembly module for UltraHDR (ISO 21496-1) gain map encoding/decoding,
+built from upstream [`google/libultrahdr`](https://github.com/google/libultrahdr)
+via Emscripten/embind.
 
-This is the low-level WASM package. For most use cases, use the `open-ultrahdr` package instead, which provides a higher-level TypeScript API.
+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:
+Requires Emscripten SDK (`emcc`, `emcmake`) and CMake 3.20+:
 
 ```bash
+source /path/to/emsdk/emsdk_env.sh
 npm run build
 ```
 
+The build vendors libultrahdr from the `third_party/libultrahdr` submodule and
+links Emscripten's `libjpeg` port (no `UHDR_BUILD_DEPS` path).
+
 ## License
 
-GPL-2.0-or-later
+Dual-licensed under `Apache-2.0 OR MIT`. See the project root [LICENSE](../LICENSE) for details.

package/package.json

@@ -1,21 +1,22 @@
 {
 	"name": "open-ultrahdr-wasm",
-	"version": "0.1.1",
-	"description": "UltraHDR (ISO 21496-1) gain map WASM implementation",
+	"version": "0.2.0",
+	"description": "UltraHDR (ISO 21496-1) gain map WASM implementation, built from upstream libultrahdr via Emscripten/embind",
 	"author": "Adam Silverstein",
-	"license": "GPL-2.0-or-later",
+	"license": "Apache-2.0 OR MIT",
 	"keywords": [
 		"ultrahdr",
 		"hdr",
 		"gain-map",
 		"iso-21496",
 		"wasm",
-		"webassembly"
+		"webassembly",
+		"libultrahdr"
 	],
 	"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": {
@@ -41,9 +42,10 @@
 		"./package.json": "./package.json"
 	},
 	"scripts": {
-		"build": "wasm-pack build --target web --out-dir pkg",
-		"build:release": "wasm-pack build --target web --out-dir pkg --release",
-		"test": "cargo test"
+		"build": "rm -rf build && emcmake cmake -S . -B build -DCMAKE_BUILD_TYPE=Release && cmake --build build -j && cp build/open_ultrahdr.js build/open_ultrahdr.wasm pkg/",
+		"build:release": "npm run build",
+		"clean": "rm -rf build pkg/open_ultrahdr.js pkg/open_ultrahdr.wasm",
+		"test": "echo 'WASM tests run via the JS package (cd ../js && npm test)'"
 	},
 	"publishConfig": {
 		"access": "public"

package/pkg/open_ultrahdr.d.ts

@@ -1,473 +1,94 @@
-/* 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.
+ * Type declarations for the Emscripten/embind-built libultrahdr WASM module.
+ *
+ * The module is produced by Emscripten with MODULARIZE=1 + EXPORT_ES6=1,
+ * exposing a default-export factory that returns a Promise resolving to the
+ * populated module. Embind populates the function and value-object surface
+ * directly on the resolved Module instance.
  *
- * This structure contains all the metadata required to interpret and apply
- * a gain map according to the ISO 21496-1 specification.
+ * Metadata at this boundary is in *log2 stops* (e.g. `hdrCapacityMax = 3.0`
+ * means 3 stops above SDR diffuse white). The embind layer converts to/from
+ * libultrahdr's linear scale internally.
  */
-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,
+export interface UltraHdrEncodeOptions {
+	baseQuality: number;
+	gainMapQuality: number;
+	targetHdrCapacity: number;
+	includeIsoMetadata: boolean;
+	includeUltrahdrV1: boolean;
+	gainMapScale: number;
 }
 
-/**
- * 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;
+export interface GainMapMetadata {
+	version: string;
+	baseRenditionIsHdr: boolean;
+	gainMapMin: number[];
+	gainMapMax: number[];
+	gamma: number[];
+	offsetSdr: number[];
+	offsetHdr: number[];
+	hdrCapacityMin: number;
+	hdrCapacityMax: 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;
+export interface UltraHdrProbeResult {
+	isValid: boolean;
+	hasPrimaryImage: boolean;
+	hasGainMap: boolean;
+	hasMetadata: boolean;
+	width: number;
+	height: number;
+	gainMapWidth: number;
+	gainMapHeight: number;
+	hdrCapacity: number;
+	metadataVersion: string;
 }
 
-/**
- * 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;
-
-/**
- * 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 interface UltraHdrDecodeResult {
+	sdrImage: Uint8Array;
+	gainMap: Uint8Array;
+	metadata: GainMapMetadata;
+	width: number;
+	height: number;
+	gainMapWidth: number;
+	gainMapHeight: number;
+}
 
-export type InitInput = RequestInfo | URL | Response | BufferSource | WebAssembly.Module;
+/** Options accepted by the module factory. */
+export interface OpenUltraHdrModuleOptions {
+	/**
+	 * Resolve URLs for files (typically the .wasm) loaded by the module at
+	 * runtime. Mirrors Emscripten's standard `locateFile` hook.
+	 */
+	locateFile?: (path: string, scriptDirectory: string) => string;
+	wasmBinary?: ArrayBuffer | Uint8Array;
+	[key: string]: unknown;
+}
 
-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_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_ultrahdrdecoderesult_free: (a: number, b: number) => void;
-    readonly __wbg_ultrahdrencodeoptions_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 __wbg_set_ultrahdrdecoderesult_sdrImage: (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 isMeaningfulHdr: (a: number) => number;
-    readonly isUltraHdr: (a: number, b: number) => number;
-    readonly validateMetadata: (a: number) => number;
-    readonly init: () => void;
-    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;
+/** Populated module instance after the factory promise resolves. */
+export interface OpenUltraHdrModule {
+	isUltraHdr(buffer: Uint8Array): boolean;
+	probeUltraHdr(buffer: Uint8Array): UltraHdrProbeResult;
+	decodeUltraHdr(buffer: Uint8Array): UltraHdrDecodeResult;
+	encodeUltraHdr(
+		sdrBuffer: Uint8Array,
+		hdrBuffer: Float32Array,
+		options: UltraHdrEncodeOptions
+	): Uint8Array;
+	extractSdrBase(buffer: Uint8Array): Uint8Array;
+	getMetadata(buffer: Uint8Array): GainMapMetadata;
+	createDefaultOptions(): UltraHdrEncodeOptions;
+	createHighQualityOptions(): UltraHdrEncodeOptions;
+	createSmallSizeOptions(): UltraHdrEncodeOptions;
+	createDefaultMetadata(): GainMapMetadata;
+	validateMetadata(metadata: GainMapMetadata): boolean;
+	estimateHdrHeadroom(metadata: GainMapMetadata): number;
+	isMeaningfulHdr(metadata: GainMapMetadata): boolean;
 }
 
-export type SyncInitInput = BufferSource | WebAssembly.Module;
+declare const createOpenUltraHdrModule: (
+	options?: OpenUltraHdrModuleOptions
+) => Promise<OpenUltraHdrModule>;
 
-/**
- * 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>;
+export default createOpenUltraHdrModule;