smart-downscaler 0.6.3 → 0.6.4

package/package.json

@@ -1,10 +1,11 @@
 {
   "name": "smart-downscaler",
+  "type": "module",
   "collaborators": [
     "Pixagram"
   ],
   "description": "Intelligent pixel art downscaler with region-aware color quantization",
-  "version": "0.6.3",
+  "version": "0.6.4",
   "license": "MIT",
   "repository": {
     "type": "git",
@@ -17,6 +18,9 @@
   ],
   "main": "smart_downscaler.js",
   "types": "smart_downscaler.d.ts",
+  "sideEffects": [
+    "./snippets/*"
+  ],
   "keywords": [
     "pixel-art",
     "image-processing",
@@ -24,4 +28,4 @@
     "quantization",
     "wasm"
   ]
-}
+}

package/smart_downscaler.d.ts

@@ -161,3 +161,134 @@ export function quantize_to_palette(image_data: Uint8Array, width: number, heigh
 export function rgb_to_oklab(r: number, g: number, b: number): Float32Array;
 
 export function version(): string;
+
+export type InitInput = RequestInfo | URL | Response | BufferSource | WebAssembly.Module;
+
+export interface InitOutput {
+    readonly memory: WebAssembly.Memory;
+    readonly __wbg_coloranalysisresult_free: (a: number, b: number) => void;
+    readonly __wbg_colorentry_free: (a: number, b: number) => void;
+    readonly __wbg_get_wasmdownscaleconfig_chroma_recovery: (a: number) => number;
+    readonly __wbg_get_wasmdownscaleconfig_color_rarity: (a: number) => number;
+    readonly __wbg_get_wasmdownscaleconfig_detail_boost: (a: number) => number;
+    readonly __wbg_get_wasmdownscaleconfig_edge_weight: (a: number) => number;
+    readonly __wbg_get_wasmdownscaleconfig_hierarchy_min_size: (a: number) => number;
+    readonly __wbg_get_wasmdownscaleconfig_hierarchy_threshold: (a: number) => number;
+    readonly __wbg_get_wasmdownscaleconfig_k_centroid: (a: number) => number;
+    readonly __wbg_get_wasmdownscaleconfig_k_centroid_iterations: (a: number) => number;
+    readonly __wbg_get_wasmdownscaleconfig_kmeans_iterations: (a: number) => number;
+    readonly __wbg_get_wasmdownscaleconfig_max_color_preprocess: (a: number) => number;
+    readonly __wbg_get_wasmdownscaleconfig_max_resolution_mp: (a: number) => number;
+    readonly __wbg_get_wasmdownscaleconfig_neighbor_weight: (a: number) => number;
+    readonly __wbg_get_wasmdownscaleconfig_palette_size: (a: number) => number;
+    readonly __wbg_get_wasmdownscaleconfig_refinement_iterations: (a: number) => number;
+    readonly __wbg_get_wasmdownscaleconfig_region_weight: (a: number) => number;
+    readonly __wbg_get_wasmdownscaleconfig_reserve_colors: (a: number) => number;
+    readonly __wbg_get_wasmdownscaleconfig_skin_protection: (a: number) => number;
+    readonly __wbg_get_wasmdownscaleconfig_slic_compactness: (a: number) => number;
+    readonly __wbg_get_wasmdownscaleconfig_slic_superpixels: (a: number) => number;
+    readonly __wbg_get_wasmdownscaleconfig_two_pass_refinement: (a: number) => number;
+    readonly __wbg_set_wasmdownscaleconfig_chroma_recovery: (a: number, b: number) => void;
+    readonly __wbg_set_wasmdownscaleconfig_color_rarity: (a: number, b: number) => void;
+    readonly __wbg_set_wasmdownscaleconfig_detail_boost: (a: number, b: number) => void;
+    readonly __wbg_set_wasmdownscaleconfig_edge_weight: (a: number, b: number) => void;
+    readonly __wbg_set_wasmdownscaleconfig_hierarchy_min_size: (a: number, b: number) => void;
+    readonly __wbg_set_wasmdownscaleconfig_hierarchy_threshold: (a: number, b: number) => void;
+    readonly __wbg_set_wasmdownscaleconfig_k_centroid: (a: number, b: number) => void;
+    readonly __wbg_set_wasmdownscaleconfig_k_centroid_iterations: (a: number, b: number) => void;
+    readonly __wbg_set_wasmdownscaleconfig_kmeans_iterations: (a: number, b: number) => void;
+    readonly __wbg_set_wasmdownscaleconfig_max_color_preprocess: (a: number, b: number) => void;
+    readonly __wbg_set_wasmdownscaleconfig_max_resolution_mp: (a: number, b: number) => void;
+    readonly __wbg_set_wasmdownscaleconfig_neighbor_weight: (a: number, b: number) => void;
+    readonly __wbg_set_wasmdownscaleconfig_palette_size: (a: number, b: number) => void;
+    readonly __wbg_set_wasmdownscaleconfig_refinement_iterations: (a: number, b: number) => void;
+    readonly __wbg_set_wasmdownscaleconfig_region_weight: (a: number, b: number) => void;
+    readonly __wbg_set_wasmdownscaleconfig_reserve_colors: (a: number, b: number) => void;
+    readonly __wbg_set_wasmdownscaleconfig_skin_protection: (a: number, b: number) => void;
+    readonly __wbg_set_wasmdownscaleconfig_slic_compactness: (a: number, b: number) => void;
+    readonly __wbg_set_wasmdownscaleconfig_slic_superpixels: (a: number, b: number) => void;
+    readonly __wbg_set_wasmdownscaleconfig_two_pass_refinement: (a: number, b: number) => void;
+    readonly __wbg_wasmdownscaleconfig_free: (a: number, b: number) => void;
+    readonly __wbg_wasmdownscaleresult_free: (a: number, b: number) => void;
+    readonly __wbg_wasmpreparedimage_free: (a: number, b: number) => void;
+    readonly analyze_colors: (a: any, b: number, c: number, d: number) => [number, number, number];
+    readonly color_distance: (a: number, b: number, c: number, d: number, e: number, f: number) => number;
+    readonly coloranalysisresult_color_count: (a: number) => number;
+    readonly coloranalysisresult_get_color: (a: number, b: number) => number;
+    readonly coloranalysisresult_get_colors_flat: (a: number) => any;
+    readonly coloranalysisresult_success: (a: number) => number;
+    readonly coloranalysisresult_to_json: (a: number) => [number, number, number];
+    readonly coloranalysisresult_total_pixels: (a: number) => number;
+    readonly colorentry_b: (a: number) => number;
+    readonly colorentry_count: (a: number) => number;
+    readonly colorentry_g: (a: number) => number;
+    readonly colorentry_hex: (a: number) => [number, number];
+    readonly colorentry_percentage: (a: number) => number;
+    readonly colorentry_r: (a: number) => number;
+    readonly downscale: (a: any, b: number, c: number, d: number, e: number, f: number) => [number, number, number];
+    readonly downscale_prepared: (a: number, b: number, c: number, d: number) => [number, number, number];
+    readonly downscale_prepared_with_palette: (a: number, b: number, c: number, d: any, e: number) => [number, number, number];
+    readonly downscale_rgba: (a: any, b: number, c: number, d: number, e: number, f: number) => [number, number, number];
+    readonly downscale_simple: (a: any, b: number, c: number, d: number, e: number, f: number) => [number, number, number];
+    readonly downscale_with_palette: (a: any, b: number, c: number, d: number, e: number, f: any, g: number) => [number, number, number];
+    readonly extract_palette_from_image: (a: any, b: number, c: number, d: number, e: number, f: number, g: number) => [number, number, number];
+    readonly get_chroma: (a: number, b: number, c: number) => number;
+    readonly get_lightness: (a: number, b: number, c: number) => number;
+    readonly get_palette_strategies: () => any;
+    readonly init: () => void;
+    readonly log: (a: number, b: number) => void;
+    readonly oklab_to_rgb: (a: number, b: number, c: number) => any;
+    readonly prepare: (a: any, b: number, c: number, d: number) => [number, number, number];
+    readonly prepare_rgba: (a: any, b: number, c: number, d: number) => [number, number, number];
+    readonly quantize_to_palette: (a: any, b: number, c: number, d: any) => [number, number, number];
+    readonly rgb_to_oklab: (a: number, b: number, c: number) => any;
+    readonly version: () => [number, number];
+    readonly wasmdownscaleconfig_exact_colors: () => number;
+    readonly wasmdownscaleconfig_fast: () => number;
+    readonly wasmdownscaleconfig_new: () => number;
+    readonly wasmdownscaleconfig_palette_strategy: (a: number) => [number, number];
+    readonly wasmdownscaleconfig_quality: () => number;
+    readonly wasmdownscaleconfig_segmentation_method: (a: number) => [number, number];
+    readonly wasmdownscaleconfig_set_palette_strategy: (a: number, b: number, c: number) => void;
+    readonly wasmdownscaleconfig_set_segmentation_method: (a: number, b: number, c: number) => void;
+    readonly wasmdownscaleconfig_vibrant: () => number;
+    readonly wasmdownscaleresult_data: (a: number) => any;
+    readonly wasmdownscaleresult_height: (a: number) => number;
+    readonly wasmdownscaleresult_indices: (a: number) => any;
+    readonly wasmdownscaleresult_palette: (a: number) => any;
+    readonly wasmdownscaleresult_palette_size: (a: number) => number;
+    readonly wasmdownscaleresult_rgb_data: (a: number) => any;
+    readonly wasmdownscaleresult_width: (a: number) => number;
+    readonly wasmpreparedimage_height: (a: number) => number;
+    readonly wasmpreparedimage_width: (a: number) => number;
+    readonly __wbindgen_exn_store: (a: number) => void;
+    readonly __externref_table_alloc: () => number;
+    readonly __wbindgen_externrefs: WebAssembly.Table;
+    readonly __wbindgen_malloc: (a: number, b: number) => number;
+    readonly __wbindgen_realloc: (a: number, b: number, c: number, d: number) => number;
+    readonly __externref_table_dealloc: (a: number) => void;
+    readonly __wbindgen_free: (a: number, b: number, c: 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>;

package/smart_downscaler.js

@@ -1,6 +1,6 @@
 /* @ts-self-types="./smart_downscaler.d.ts" */
 
-class ColorAnalysisResult {
+export class ColorAnalysisResult {
     static __wrap(ptr) {
         ptr = ptr >>> 0;
         const obj = Object.create(ColorAnalysisResult.prototype);
@@ -66,9 +66,8 @@ class ColorAnalysisResult {
     }
 }
 if (Symbol.dispose) ColorAnalysisResult.prototype[Symbol.dispose] = ColorAnalysisResult.prototype.free;
-exports.ColorAnalysisResult = ColorAnalysisResult;
 
-class ColorEntry {
+export class ColorEntry {
     static __wrap(ptr) {
         ptr = ptr >>> 0;
         const obj = Object.create(ColorEntry.prototype);
@@ -138,9 +137,8 @@ class ColorEntry {
     }
 }
 if (Symbol.dispose) ColorEntry.prototype[Symbol.dispose] = ColorEntry.prototype.free;
-exports.ColorEntry = ColorEntry;
 
-class WasmDownscaleConfig {
+export class WasmDownscaleConfig {
     static __wrap(ptr) {
         ptr = ptr >>> 0;
         const obj = Object.create(WasmDownscaleConfig.prototype);
@@ -510,9 +508,8 @@ class WasmDownscaleConfig {
     }
 }
 if (Symbol.dispose) WasmDownscaleConfig.prototype[Symbol.dispose] = WasmDownscaleConfig.prototype.free;
-exports.WasmDownscaleConfig = WasmDownscaleConfig;
 
-class WasmDownscaleResult {
+export class WasmDownscaleResult {
     static __wrap(ptr) {
         ptr = ptr >>> 0;
         const obj = Object.create(WasmDownscaleResult.prototype);
@@ -581,7 +578,6 @@ class WasmDownscaleResult {
     }
 }
 if (Symbol.dispose) WasmDownscaleResult.prototype[Symbol.dispose] = WasmDownscaleResult.prototype.free;
-exports.WasmDownscaleResult = WasmDownscaleResult;
 
 /**
  * Opaque handle holding the prepared (preprocessed + segmented) source image.
@@ -591,7 +587,7 @@ exports.WasmDownscaleResult = WasmDownscaleResult;
  * size and target dimensions may differ on every [`downscale_prepared`] call.
  * If you change resolution / color-preprocess / segmentation settings, prepare again.
  */
-class WasmPreparedImage {
+export class WasmPreparedImage {
     static __wrap(ptr) {
         ptr = ptr >>> 0;
         const obj = Object.create(WasmPreparedImage.prototype);
@@ -625,7 +621,6 @@ class WasmPreparedImage {
     }
 }
 if (Symbol.dispose) WasmPreparedImage.prototype[Symbol.dispose] = WasmPreparedImage.prototype.free;
-exports.WasmPreparedImage = WasmPreparedImage;
 
 /**
  * Analyze colors — FIX: uses HashMap<u32, usize> for O(1) lookup (was O(n) linear scan)
@@ -634,7 +629,7 @@ exports.WasmPreparedImage = WasmPreparedImage;
  * @param {string} sort_method
  * @returns {ColorAnalysisResult}
  */
-function analyze_colors(image_data, max_colors, sort_method) {
+export function analyze_colors(image_data, max_colors, sort_method) {
     const ptr0 = passStringToWasm0(sort_method, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
     const len0 = WASM_VECTOR_LEN;
     const ret = wasm.analyze_colors(image_data, max_colors, ptr0, len0);
@@ -643,7 +638,6 @@ function analyze_colors(image_data, max_colors, sort_method) {
     }
     return ColorAnalysisResult.__wrap(ret[0]);
 }
-exports.analyze_colors = analyze_colors;
 
 /**
  * @param {number} r1
@@ -654,11 +648,10 @@ exports.analyze_colors = analyze_colors;
  * @param {number} b2
  * @returns {number}
  */
-function color_distance(r1, g1, b1, r2, g2, b2) {
+export function color_distance(r1, g1, b1, r2, g2, b2) {
     const ret = wasm.color_distance(r1, g1, b1, r2, g2, b2);
     return ret;
 }
-exports.color_distance = color_distance;
 
 /**
  * @param {Uint8Array} image_data
@@ -669,7 +662,7 @@ exports.color_distance = color_distance;
  * @param {WasmDownscaleConfig | null} [config]
  * @returns {WasmDownscaleResult}
  */
-function downscale(image_data, width, height, target_width, target_height, config) {
+export function downscale(image_data, width, height, target_width, target_height, config) {
     let ptr0 = 0;
     if (!isLikeNone(config)) {
         _assertClass(config, WasmDownscaleConfig);
@@ -681,7 +674,6 @@ function downscale(image_data, width, height, target_width, target_height, confi
     }
     return WasmDownscaleResult.__wrap(ret[0]);
 }
-exports.downscale = downscale;
 
 /**
  * Downscale a prepared image. Pass an optional `config` to override per-target
@@ -694,7 +686,7 @@ exports.downscale = downscale;
  * @param {WasmDownscaleConfig | null} [config]
  * @returns {WasmDownscaleResult}
  */
-function downscale_prepared(prepared, target_width, target_height, config) {
+export function downscale_prepared(prepared, target_width, target_height, config) {
     _assertClass(prepared, WasmPreparedImage);
     let ptr0 = 0;
     if (!isLikeNone(config)) {
@@ -707,7 +699,6 @@ function downscale_prepared(prepared, target_width, target_height, config) {
     }
     return WasmDownscaleResult.__wrap(ret[0]);
 }
-exports.downscale_prepared = downscale_prepared;
 
 /**
  * Downscale a prepared image with a caller-supplied palette.
@@ -718,7 +709,7 @@ exports.downscale_prepared = downscale_prepared;
  * @param {WasmDownscaleConfig | null} [config]
  * @returns {WasmDownscaleResult}
  */
-function downscale_prepared_with_palette(prepared, target_width, target_height, palette_data, config) {
+export function downscale_prepared_with_palette(prepared, target_width, target_height, palette_data, config) {
     _assertClass(prepared, WasmPreparedImage);
     let ptr0 = 0;
     if (!isLikeNone(config)) {
@@ -731,7 +722,6 @@ function downscale_prepared_with_palette(prepared, target_width, target_height,
     }
     return WasmDownscaleResult.__wrap(ret[0]);
 }
-exports.downscale_prepared_with_palette = downscale_prepared_with_palette;
 
 /**
  * @param {Uint8ClampedArray} image_data
@@ -742,7 +732,7 @@ exports.downscale_prepared_with_palette = downscale_prepared_with_palette;
  * @param {WasmDownscaleConfig | null} [config]
  * @returns {WasmDownscaleResult}
  */
-function downscale_rgba(image_data, width, height, target_width, target_height, config) {
+export function downscale_rgba(image_data, width, height, target_width, target_height, config) {
     let ptr0 = 0;
     if (!isLikeNone(config)) {
         _assertClass(config, WasmDownscaleConfig);
@@ -754,7 +744,6 @@ function downscale_rgba(image_data, width, height, target_width, target_height,
     }
     return WasmDownscaleResult.__wrap(ret[0]);
 }
-exports.downscale_rgba = downscale_rgba;
 
 /**
  * @param {Uint8Array} image_data
@@ -765,14 +754,13 @@ exports.downscale_rgba = downscale_rgba;
  * @param {number} num_colors
  * @returns {WasmDownscaleResult}
  */
-function downscale_simple(image_data, width, height, target_width, target_height, num_colors) {
+export function downscale_simple(image_data, width, height, target_width, target_height, num_colors) {
     const ret = wasm.downscale_simple(image_data, width, height, target_width, target_height, num_colors);
     if (ret[2]) {
         throw takeFromExternrefTable0(ret[1]);
     }
     return WasmDownscaleResult.__wrap(ret[0]);
 }
-exports.downscale_simple = downscale_simple;
 
 /**
  * @param {Uint8Array} image_data
@@ -784,7 +772,7 @@ exports.downscale_simple = downscale_simple;
  * @param {WasmDownscaleConfig | null} [config]
  * @returns {WasmDownscaleResult}
  */
-function downscale_with_palette(image_data, width, height, target_width, target_height, palette_data, config) {
+export function downscale_with_palette(image_data, width, height, target_width, target_height, palette_data, config) {
     let ptr0 = 0;
     if (!isLikeNone(config)) {
         _assertClass(config, WasmDownscaleConfig);
@@ -796,7 +784,6 @@ function downscale_with_palette(image_data, width, height, target_width, target_
     }
     return WasmDownscaleResult.__wrap(ret[0]);
 }
-exports.downscale_with_palette = downscale_with_palette;
 
 /**
  * @param {Uint8Array} image_data
@@ -807,7 +794,7 @@ exports.downscale_with_palette = downscale_with_palette;
  * @param {string | null} [strategy]
  * @returns {Uint8Array}
  */
-function extract_palette_from_image(image_data, _width, _height, num_colors, kmeans_iterations, strategy) {
+export function extract_palette_from_image(image_data, _width, _height, num_colors, kmeans_iterations, strategy) {
     var ptr0 = isLikeNone(strategy) ? 0 : passStringToWasm0(strategy, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
     var len0 = WASM_VECTOR_LEN;
     const ret = wasm.extract_palette_from_image(image_data, _width, _height, num_colors, kmeans_iterations, ptr0, len0);
@@ -816,7 +803,6 @@ function extract_palette_from_image(image_data, _width, _height, num_colors, kme
     }
     return takeFromExternrefTable0(ret[0]);
 }
-exports.extract_palette_from_image = extract_palette_from_image;
 
 /**
  * @param {number} r
@@ -824,11 +810,10 @@ exports.extract_palette_from_image = extract_palette_from_image;
  * @param {number} b
  * @returns {number}
  */
-function get_chroma(r, g, b) {
+export function get_chroma(r, g, b) {
     const ret = wasm.get_chroma(r, g, b);
     return ret;
 }
-exports.get_chroma = get_chroma;
 
 /**
  * @param {number} r
@@ -836,35 +821,31 @@ exports.get_chroma = get_chroma;
  * @param {number} b
  * @returns {number}
  */
-function get_lightness(r, g, b) {
+export function get_lightness(r, g, b) {
     const ret = wasm.get_lightness(r, g, b);
     return ret;
 }
-exports.get_lightness = get_lightness;
 
 /**
  * @returns {Array<any>}
  */
-function get_palette_strategies() {
+export function get_palette_strategies() {
     const ret = wasm.get_palette_strategies();
     return ret;
 }
-exports.get_palette_strategies = get_palette_strategies;
 
-function init() {
+export function init() {
     wasm.init();
 }
-exports.init = init;
 
 /**
  * @param {string} message
  */
-function log(message) {
+export function log(message) {
     const ptr0 = passStringToWasm0(message, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
     const len0 = WASM_VECTOR_LEN;
     wasm.log(ptr0, len0);
 }
-exports.log = log;
 
 /**
  * @param {number} l
@@ -872,11 +853,10 @@ exports.log = log;
  * @param {number} b
  * @returns {Uint8Array}
  */
-function oklab_to_rgb(l, a, b) {
+export function oklab_to_rgb(l, a, b) {
     const ret = wasm.oklab_to_rgb(l, a, b);
     return ret;
 }
-exports.oklab_to_rgb = oklab_to_rgb;
 
 /**
  * Prepare from a `Uint8Array` (RGBA).
@@ -886,7 +866,7 @@ exports.oklab_to_rgb = oklab_to_rgb;
  * @param {WasmDownscaleConfig | null} [config]
  * @returns {WasmPreparedImage}
  */
-function prepare(image_data, width, height, config) {
+export function prepare(image_data, width, height, config) {
     let ptr0 = 0;
     if (!isLikeNone(config)) {
         _assertClass(config, WasmDownscaleConfig);
@@ -898,7 +878,6 @@ function prepare(image_data, width, height, config) {
     }
     return WasmPreparedImage.__wrap(ret[0]);
 }
-exports.prepare = prepare;
 
 /**
  * Prepare from a `Uint8ClampedArray` (canvas `getImageData`).
@@ -908,7 +887,7 @@ exports.prepare = prepare;
  * @param {WasmDownscaleConfig | null} [config]
  * @returns {WasmPreparedImage}
  */
-function prepare_rgba(image_data, width, height, config) {
+export function prepare_rgba(image_data, width, height, config) {
     let ptr0 = 0;
     if (!isLikeNone(config)) {
         _assertClass(config, WasmDownscaleConfig);
@@ -920,7 +899,6 @@ function prepare_rgba(image_data, width, height, config) {
     }
     return WasmPreparedImage.__wrap(ret[0]);
 }
-exports.prepare_rgba = prepare_rgba;
 
 /**
  * Quantize to palette — FIX: compute Oklab once per pixel (was twice)
@@ -930,14 +908,13 @@ exports.prepare_rgba = prepare_rgba;
  * @param {Uint8Array} palette_data
  * @returns {WasmDownscaleResult}
  */
-function quantize_to_palette(image_data, width, height, palette_data) {
+export function quantize_to_palette(image_data, width, height, palette_data) {
     const ret = wasm.quantize_to_palette(image_data, width, height, palette_data);
     if (ret[2]) {
         throw takeFromExternrefTable0(ret[1]);
     }
     return WasmDownscaleResult.__wrap(ret[0]);
 }
-exports.quantize_to_palette = quantize_to_palette;
 
 /**
  * @param {number} r
@@ -945,16 +922,15 @@ exports.quantize_to_palette = quantize_to_palette;
  * @param {number} b
  * @returns {Float32Array}
  */
-function rgb_to_oklab(r, g, b) {
+export function rgb_to_oklab(r, g, b) {
     const ret = wasm.rgb_to_oklab(r, g, b);
     return ret;
 }
-exports.rgb_to_oklab = rgb_to_oklab;
 
 /**
  * @returns {string}
  */
-function version() {
+export function version() {
     let deferred1_0;
     let deferred1_1;
     try {
@@ -966,7 +942,6 @@ function version() {
         wasm.__wbindgen_free(deferred1_0, deferred1_1, 1);
     }
 }
-exports.version = version;
 
 function __wbg_get_imports() {
     const import0 = {
@@ -1156,7 +1131,15 @@ function takeFromExternrefTable0(idx) {
 
 let cachedTextDecoder = new TextDecoder('utf-8', { ignoreBOM: true, fatal: true });
 cachedTextDecoder.decode();
+const MAX_SAFARI_DECODE_BYTES = 2146435072;
+let numBytesDecoded = 0;
 function decodeText(ptr, len) {
+    numBytesDecoded += len;
+    if (numBytesDecoded >= MAX_SAFARI_DECODE_BYTES) {
+        cachedTextDecoder = new TextDecoder('utf-8', { ignoreBOM: true, fatal: true });
+        cachedTextDecoder.decode();
+        numBytesDecoded = len;
+    }
     return cachedTextDecoder.decode(getUint8ArrayMemory0().subarray(ptr, ptr + len));
 }
 
@@ -1175,8 +1158,94 @@ if (!('encodeInto' in cachedTextEncoder)) {
 
 let WASM_VECTOR_LEN = 0;
 
-const wasmPath = `${__dirname}/smart_downscaler_bg.wasm`;
-const wasmBytes = require('fs').readFileSync(wasmPath);
-const wasmModule = new WebAssembly.Module(wasmBytes);
-const wasm = new WebAssembly.Instance(wasmModule, __wbg_get_imports()).exports;
-wasm.__wbindgen_start();
+let wasmModule, wasm;
+function __wbg_finalize_init(instance, module) {
+    wasm = instance.exports;
+    wasmModule = module;
+    cachedUint8ArrayMemory0 = null;
+    wasm.__wbindgen_start();
+    return wasm;
+}
+
+async function __wbg_load(module, imports) {
+    if (typeof Response === 'function' && module instanceof Response) {
+        if (typeof WebAssembly.instantiateStreaming === 'function') {
+            try {
+                return await WebAssembly.instantiateStreaming(module, imports);
+            } catch (e) {
+                const validResponse = module.ok && expectedResponseType(module.type);
+
+                if (validResponse && module.headers.get('Content-Type') !== 'application/wasm') {
+                    console.warn("`WebAssembly.instantiateStreaming` failed because your server does not serve Wasm with `application/wasm` MIME type. Falling back to `WebAssembly.instantiate` which is slower. Original error:\n", e);
+
+                } else { throw e; }
+            }
+        }
+
+        const bytes = await module.arrayBuffer();
+        return await WebAssembly.instantiate(bytes, imports);
+    } else {
+        const instance = await WebAssembly.instantiate(module, imports);
+
+        if (instance instanceof WebAssembly.Instance) {
+            return { instance, module };
+        } else {
+            return instance;
+        }
+    }
+
+    function expectedResponseType(type) {
+        switch (type) {
+            case 'basic': case 'cors': case 'default': return true;
+        }
+        return false;
+    }
+}
+
+function initSync(module) {
+    if (wasm !== undefined) return wasm;
+
+
+    if (module !== undefined) {
+        if (Object.getPrototypeOf(module) === Object.prototype) {
+            ({module} = module)
+        } else {
+            console.warn('using deprecated parameters for `initSync()`; pass a single object instead')
+        }
+    }
+
+    const imports = __wbg_get_imports();
+    if (!(module instanceof WebAssembly.Module)) {
+        module = new WebAssembly.Module(module);
+    }
+    const instance = new WebAssembly.Instance(module, imports);
+    return __wbg_finalize_init(instance, module);
+}
+
+async function __wbg_init(module_or_path) {
+    if (wasm !== undefined) return wasm;
+
+
+    if (module_or_path !== undefined) {
+        if (Object.getPrototypeOf(module_or_path) === Object.prototype) {
+            ({module_or_path} = module_or_path)
+        } else {
+            console.warn('using deprecated parameters for the initialization function; pass a single object instead')
+        }
+    }
+
+    if (module_or_path === undefined) {
+        module_or_path = new URL('smart_downscaler_bg.wasm', import.meta.url);
+    }
+    const imports = __wbg_get_imports();
+
+    if (typeof module_or_path === 'string' || (typeof Request === 'function' && module_or_path instanceof Request) || (typeof URL === 'function' && module_or_path instanceof URL)) {
+        module_or_path = fetch(module_or_path);
+    }
+
+    const { instance, module } = await __wbg_load(await module_or_path, imports);
+
+    return __wbg_finalize_init(instance, module);
+}
+
+export { initSync, __wbg_init as default };