@pixagram/renderart 0.1.3 → 0.2.1

package/dist/index.js

@@ -1,795 +1,5 @@
 'use strict';
 
-var _documentCurrentScript = typeof document !== 'undefined' ? document.currentScript : null;
-var __defProp = Object.defineProperty;
-var __getOwnPropNames = Object.getOwnPropertyNames;
-var __esm = (fn, res) => function __init() {
-  return fn && (res = (0, fn[__getOwnPropNames(fn)[0]])(fn = 0)), res;
-};
-var __export = (target, all) => {
-  for (var name in all)
-    __defProp(target, name, { get: all[name], enumerable: true });
-};
-
-// pkg/renderart_wasm.js
-var renderart_wasm_exports = {};
-__export(renderart_wasm_exports, {
-  CrtConfig: () => CrtConfig,
-  HexConfig: () => HexConfig,
-  HexOrientation: () => HexOrientation,
-  UpscaleResult: () => UpscaleResult,
-  XbrzConfig: () => XbrzConfig,
-  crt_upscale: () => crt_upscale,
-  crt_upscale_config: () => crt_upscale_config,
-  default: () => renderart_wasm_default,
-  get_memory: () => get_memory,
-  hex_get_dimensions: () => hex_get_dimensions,
-  hex_upscale: () => hex_upscale,
-  hex_upscale_config: () => hex_upscale_config,
-  init: () => init,
-  initSync: () => initSync,
-  xbrz_upscale: () => xbrz_upscale,
-  xbrz_upscale_config: () => xbrz_upscale_config
-});
-function _assertClass(instance, klass) {
-  if (!(instance instanceof klass)) {
-    throw new Error(`expected instance of ${klass.name}`);
-  }
-}
-function getArrayU32FromWasm0(ptr, len) {
-  ptr = ptr >>> 0;
-  return getUint32ArrayMemory0().subarray(ptr / 4, ptr / 4 + len);
-}
-function getDataViewMemory0() {
-  if (cachedDataViewMemory0 === null || cachedDataViewMemory0.buffer.detached === true || cachedDataViewMemory0.buffer.detached === void 0 && cachedDataViewMemory0.buffer !== wasm.memory.buffer) {
-    cachedDataViewMemory0 = new DataView(wasm.memory.buffer);
-  }
-  return cachedDataViewMemory0;
-}
-function getStringFromWasm0(ptr, len) {
-  ptr = ptr >>> 0;
-  return decodeText(ptr, len);
-}
-function getUint32ArrayMemory0() {
-  if (cachedUint32ArrayMemory0 === null || cachedUint32ArrayMemory0.byteLength === 0) {
-    cachedUint32ArrayMemory0 = new Uint32Array(wasm.memory.buffer);
-  }
-  return cachedUint32ArrayMemory0;
-}
-function getUint8ArrayMemory0() {
-  if (cachedUint8ArrayMemory0 === null || cachedUint8ArrayMemory0.byteLength === 0) {
-    cachedUint8ArrayMemory0 = new Uint8Array(wasm.memory.buffer);
-  }
-  return cachedUint8ArrayMemory0;
-}
-function passArray8ToWasm0(arg, malloc) {
-  const ptr = malloc(arg.length * 1, 1) >>> 0;
-  getUint8ArrayMemory0().set(arg, ptr / 1);
-  WASM_VECTOR_LEN = arg.length;
-  return ptr;
-}
-function passStringToWasm0(arg, malloc, realloc) {
-  if (realloc === void 0) {
-    const buf = cachedTextEncoder.encode(arg);
-    const ptr2 = malloc(buf.length, 1) >>> 0;
-    getUint8ArrayMemory0().subarray(ptr2, ptr2 + buf.length).set(buf);
-    WASM_VECTOR_LEN = buf.length;
-    return ptr2;
-  }
-  let len = arg.length;
-  let ptr = malloc(len, 1) >>> 0;
-  const mem = getUint8ArrayMemory0();
-  let offset = 0;
-  for (; offset < len; offset++) {
-    const code = arg.charCodeAt(offset);
-    if (code > 127) break;
-    mem[ptr + offset] = code;
-  }
-  if (offset !== len) {
-    if (offset !== 0) {
-      arg = arg.slice(offset);
-    }
-    ptr = realloc(ptr, len, len = offset + arg.length * 3, 1) >>> 0;
-    const view = getUint8ArrayMemory0().subarray(ptr + offset, ptr + len);
-    const ret = cachedTextEncoder.encodeInto(arg, view);
-    offset += ret.written;
-    ptr = realloc(ptr, len, offset, 1) >>> 0;
-  }
-  WASM_VECTOR_LEN = offset;
-  return ptr;
-}
-function takeFromExternrefTable0(idx) {
-  const value = wasm.__wbindgen_externrefs.get(idx);
-  wasm.__externref_table_dealloc(idx);
-  return value;
-}
-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));
-}
-function crt_upscale(input, src_w, src_h, scale) {
-  const ptr0 = passArray8ToWasm0(input, wasm.__wbindgen_malloc);
-  const len0 = WASM_VECTOR_LEN;
-  const ret = wasm.crt_upscale(ptr0, len0, src_w, src_h, scale);
-  if (ret[2]) {
-    throw takeFromExternrefTable0(ret[1]);
-  }
-  return UpscaleResult.__wrap(ret[0]);
-}
-function crt_upscale_config(input, src_w, src_h, scale, config) {
-  const ptr0 = passArray8ToWasm0(input, wasm.__wbindgen_malloc);
-  const len0 = WASM_VECTOR_LEN;
-  _assertClass(config, CrtConfig);
-  const ret = wasm.crt_upscale_config(ptr0, len0, src_w, src_h, scale, config.__wbg_ptr);
-  if (ret[2]) {
-    throw takeFromExternrefTable0(ret[1]);
-  }
-  return UpscaleResult.__wrap(ret[0]);
-}
-function get_memory() {
-  const ret = wasm.get_memory();
-  return ret;
-}
-function hex_get_dimensions(src_w, src_h, scale, orientation) {
-  const ret = wasm.hex_get_dimensions(src_w, src_h, scale, orientation);
-  var v1 = getArrayU32FromWasm0(ret[0], ret[1]).slice();
-  wasm.__wbindgen_free(ret[0], ret[1] * 4, 4);
-  return v1;
-}
-function hex_upscale(input, src_w, src_h, scale) {
-  const ptr0 = passArray8ToWasm0(input, wasm.__wbindgen_malloc);
-  const len0 = WASM_VECTOR_LEN;
-  const ret = wasm.hex_upscale(ptr0, len0, src_w, src_h, scale);
-  if (ret[2]) {
-    throw takeFromExternrefTable0(ret[1]);
-  }
-  return UpscaleResult.__wrap(ret[0]);
-}
-function hex_upscale_config(input, src_w, src_h, scale, config) {
-  const ptr0 = passArray8ToWasm0(input, wasm.__wbindgen_malloc);
-  const len0 = WASM_VECTOR_LEN;
-  _assertClass(config, HexConfig);
-  const ret = wasm.hex_upscale_config(ptr0, len0, src_w, src_h, scale, config.__wbg_ptr);
-  if (ret[2]) {
-    throw takeFromExternrefTable0(ret[1]);
-  }
-  return UpscaleResult.__wrap(ret[0]);
-}
-function init() {
-  wasm.init();
-}
-function xbrz_upscale(input, src_w, src_h, scale) {
-  const ptr0 = passArray8ToWasm0(input, wasm.__wbindgen_malloc);
-  const len0 = WASM_VECTOR_LEN;
-  const ret = wasm.xbrz_upscale(ptr0, len0, src_w, src_h, scale);
-  if (ret[2]) {
-    throw takeFromExternrefTable0(ret[1]);
-  }
-  return UpscaleResult.__wrap(ret[0]);
-}
-function xbrz_upscale_config(input, src_w, src_h, scale, config) {
-  const ptr0 = passArray8ToWasm0(input, wasm.__wbindgen_malloc);
-  const len0 = WASM_VECTOR_LEN;
-  _assertClass(config, XbrzConfig);
-  const ret = wasm.xbrz_upscale_config(ptr0, len0, src_w, src_h, scale, config.__wbg_ptr);
-  if (ret[2]) {
-    throw takeFromExternrefTable0(ret[1]);
-  }
-  return UpscaleResult.__wrap(ret[0]);
-}
-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 && EXPECTED_RESPONSE_TYPES.has(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 __wbg_get_imports() {
-  const imports = {};
-  imports.wbg = {};
-  imports.wbg.__wbg___wbindgen_memory_a342e963fbcabd68 = function() {
-    const ret = wasm.memory;
-    return ret;
-  };
-  imports.wbg.__wbg___wbindgen_throw_dd24417ed36fc46e = function(arg0, arg1) {
-    throw new Error(getStringFromWasm0(arg0, arg1));
-  };
-  imports.wbg.__wbg_error_7534b8e9a36f1ab4 = function(arg0, arg1) {
-    let deferred0_0;
-    let deferred0_1;
-    try {
-      deferred0_0 = arg0;
-      deferred0_1 = arg1;
-      console.error(getStringFromWasm0(arg0, arg1));
-    } finally {
-      wasm.__wbindgen_free(deferred0_0, deferred0_1, 1);
-    }
-  };
-  imports.wbg.__wbg_new_8a6f238a6ece86ea = function() {
-    const ret = new Error();
-    return ret;
-  };
-  imports.wbg.__wbg_stack_0ed75d68575b0f3c = function(arg0, arg1) {
-    const ret = arg1.stack;
-    const ptr1 = passStringToWasm0(ret, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
-    const len1 = WASM_VECTOR_LEN;
-    getDataViewMemory0().setInt32(arg0 + 4 * 1, len1, true);
-    getDataViewMemory0().setInt32(arg0 + 4 * 0, ptr1, true);
-  };
-  imports.wbg.__wbindgen_cast_2241b6af4c4b2941 = function(arg0, arg1) {
-    const ret = getStringFromWasm0(arg0, arg1);
-    return ret;
-  };
-  imports.wbg.__wbindgen_init_externref_table = function() {
-    const table = wasm.__wbindgen_externrefs;
-    const offset = table.grow(4);
-    table.set(0, void 0);
-    table.set(offset + 0, void 0);
-    table.set(offset + 1, null);
-    table.set(offset + 2, true);
-    table.set(offset + 3, false);
-  };
-  return imports;
-}
-function __wbg_finalize_init(instance, module) {
-  wasm = instance.exports;
-  __wbg_init.__wbindgen_wasm_module = module;
-  cachedDataViewMemory0 = null;
-  cachedUint32ArrayMemory0 = null;
-  cachedUint8ArrayMemory0 = null;
-  wasm.__wbindgen_start();
-  return wasm;
-}
-function initSync(module) {
-  if (wasm !== void 0) return wasm;
-  if (typeof 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 !== void 0) return wasm;
-  if (typeof 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 (typeof module_or_path === "undefined") {
-    module_or_path = new URL("renderart_wasm_bg.wasm", (typeof document === 'undefined' ? require('u' + 'rl').pathToFileURL(__filename).href : (_documentCurrentScript && _documentCurrentScript.tagName.toUpperCase() === 'SCRIPT' && _documentCurrentScript.src || new URL('index.js', document.baseURI).href)));
-  }
-  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);
-}
-var wasm, cachedDataViewMemory0, cachedUint32ArrayMemory0, cachedUint8ArrayMemory0, cachedTextDecoder, MAX_SAFARI_DECODE_BYTES, numBytesDecoded, cachedTextEncoder, WASM_VECTOR_LEN, CrtConfigFinalization, HexConfigFinalization, UpscaleResultFinalization, XbrzConfigFinalization, CrtConfig, HexConfig, HexOrientation, UpscaleResult, XbrzConfig, EXPECTED_RESPONSE_TYPES, renderart_wasm_default;
-var init_renderart_wasm = __esm({
-  "pkg/renderart_wasm.js"() {
-    cachedDataViewMemory0 = null;
-    cachedUint32ArrayMemory0 = null;
-    cachedUint8ArrayMemory0 = null;
-    cachedTextDecoder = new TextDecoder("utf-8", { ignoreBOM: true, fatal: true });
-    cachedTextDecoder.decode();
-    MAX_SAFARI_DECODE_BYTES = 2146435072;
-    numBytesDecoded = 0;
-    cachedTextEncoder = new TextEncoder();
-    if (!("encodeInto" in cachedTextEncoder)) {
-      cachedTextEncoder.encodeInto = function(arg, view) {
-        const buf = cachedTextEncoder.encode(arg);
-        view.set(buf);
-        return {
-          read: arg.length,
-          written: buf.length
-        };
-      };
-    }
-    WASM_VECTOR_LEN = 0;
-    CrtConfigFinalization = typeof FinalizationRegistry === "undefined" ? { register: () => {
-    }, unregister: () => {
-    } } : new FinalizationRegistry((ptr) => wasm.__wbg_crtconfig_free(ptr >>> 0, 1));
-    HexConfigFinalization = typeof FinalizationRegistry === "undefined" ? { register: () => {
-    }, unregister: () => {
-    } } : new FinalizationRegistry((ptr) => wasm.__wbg_hexconfig_free(ptr >>> 0, 1));
-    UpscaleResultFinalization = typeof FinalizationRegistry === "undefined" ? { register: () => {
-    }, unregister: () => {
-    } } : new FinalizationRegistry((ptr) => wasm.__wbg_upscaleresult_free(ptr >>> 0, 1));
-    XbrzConfigFinalization = typeof FinalizationRegistry === "undefined" ? { register: () => {
-    }, unregister: () => {
-    } } : new FinalizationRegistry((ptr) => wasm.__wbg_xbrzconfig_free(ptr >>> 0, 1));
-    CrtConfig = class _CrtConfig {
-      static __wrap(ptr) {
-        ptr = ptr >>> 0;
-        const obj = Object.create(_CrtConfig.prototype);
-        obj.__wbg_ptr = ptr;
-        CrtConfigFinalization.register(obj, obj.__wbg_ptr, obj);
-        return obj;
-      }
-      __destroy_into_raw() {
-        const ptr = this.__wbg_ptr;
-        this.__wbg_ptr = 0;
-        CrtConfigFinalization.unregister(this);
-        return ptr;
-      }
-      free() {
-        const ptr = this.__destroy_into_raw();
-        wasm.__wbg_crtconfig_free(ptr, 0);
-      }
-      /**
-       * Horizontal warp intensity (0.0 - 0.1)
-       * @returns {number}
-       */
-      get warp_x() {
-        const ret = wasm.__wbg_get_crtconfig_warp_x(this.__wbg_ptr);
-        return ret;
-      }
-      /**
-       * Horizontal warp intensity (0.0 - 0.1)
-       * @param {number} arg0
-       */
-      set warp_x(arg0) {
-        wasm.__wbg_set_crtconfig_warp_x(this.__wbg_ptr, arg0);
-      }
-      /**
-       * Vertical warp intensity (0.0 - 0.1)
-       * @returns {number}
-       */
-      get warp_y() {
-        const ret = wasm.__wbg_get_crtconfig_warp_y(this.__wbg_ptr);
-        return ret;
-      }
-      /**
-       * Vertical warp intensity (0.0 - 0.1)
-       * @param {number} arg0
-       */
-      set warp_y(arg0) {
-        wasm.__wbg_set_crtconfig_warp_y(this.__wbg_ptr, arg0);
-      }
-      /**
-       * Scanline hardness (-10.0 to 0.0, more negative = sharper)
-       * @returns {number}
-       */
-      get scan_hardness() {
-        const ret = wasm.__wbg_get_crtconfig_scan_hardness(this.__wbg_ptr);
-        return ret;
-      }
-      /**
-       * Scanline hardness (-10.0 to 0.0, more negative = sharper)
-       * @param {number} arg0
-       */
-      set scan_hardness(arg0) {
-        wasm.__wbg_set_crtconfig_scan_hardness(this.__wbg_ptr, arg0);
-      }
-      /**
-       * Scanline opacity (0.0 - 1.0)
-       * @returns {number}
-       */
-      get scan_opacity() {
-        const ret = wasm.__wbg_get_crtconfig_scan_opacity(this.__wbg_ptr);
-        return ret;
-      }
-      /**
-       * Scanline opacity (0.0 - 1.0)
-       * @param {number} arg0
-       */
-      set scan_opacity(arg0) {
-        wasm.__wbg_set_crtconfig_scan_opacity(this.__wbg_ptr, arg0);
-      }
-      /**
-       * Shadow mask opacity (0.0 - 1.0)
-       * @returns {number}
-       */
-      get mask_opacity() {
-        const ret = wasm.__wbg_get_crtconfig_mask_opacity(this.__wbg_ptr);
-        return ret;
-      }
-      /**
-       * Shadow mask opacity (0.0 - 1.0)
-       * @param {number} arg0
-       */
-      set mask_opacity(arg0) {
-        wasm.__wbg_set_crtconfig_mask_opacity(this.__wbg_ptr, arg0);
-      }
-      /**
-       * Enable barrel distortion
-       * @returns {boolean}
-       */
-      get enable_warp() {
-        const ret = wasm.__wbg_get_crtconfig_enable_warp(this.__wbg_ptr);
-        return ret !== 0;
-      }
-      /**
-       * Enable barrel distortion
-       * @param {boolean} arg0
-       */
-      set enable_warp(arg0) {
-        wasm.__wbg_set_crtconfig_enable_warp(this.__wbg_ptr, arg0);
-      }
-      /**
-       * Enable scanlines
-       * @returns {boolean}
-       */
-      get enable_scanlines() {
-        const ret = wasm.__wbg_get_crtconfig_enable_scanlines(this.__wbg_ptr);
-        return ret !== 0;
-      }
-      /**
-       * Enable scanlines
-       * @param {boolean} arg0
-       */
-      set enable_scanlines(arg0) {
-        wasm.__wbg_set_crtconfig_enable_scanlines(this.__wbg_ptr, arg0);
-      }
-      /**
-       * Enable shadow mask
-       * @returns {boolean}
-       */
-      get enable_mask() {
-        const ret = wasm.__wbg_get_crtconfig_enable_mask(this.__wbg_ptr);
-        return ret !== 0;
-      }
-      /**
-       * Enable shadow mask
-       * @param {boolean} arg0
-       */
-      set enable_mask(arg0) {
-        wasm.__wbg_set_crtconfig_enable_mask(this.__wbg_ptr, arg0);
-      }
-      constructor() {
-        const ret = wasm.crtconfig_new();
-        this.__wbg_ptr = ret >>> 0;
-        CrtConfigFinalization.register(this, this.__wbg_ptr, this);
-        return this;
-      }
-      /**
-       * Create preset: Authentic CRT look
-       * @returns {CrtConfig}
-       */
-      static preset_authentic() {
-        const ret = wasm.crtconfig_preset_authentic();
-        return _CrtConfig.__wrap(ret);
-      }
-      /**
-       * Create preset: Subtle modern look
-       * @returns {CrtConfig}
-       */
-      static preset_subtle() {
-        const ret = wasm.crtconfig_preset_subtle();
-        return _CrtConfig.__wrap(ret);
-      }
-      /**
-       * Create preset: Flat screen (no curvature)
-       * @returns {CrtConfig}
-       */
-      static preset_flat() {
-        const ret = wasm.crtconfig_preset_flat();
-        return _CrtConfig.__wrap(ret);
-      }
-    };
-    if (Symbol.dispose) CrtConfig.prototype[Symbol.dispose] = CrtConfig.prototype.free;
-    HexConfig = class _HexConfig {
-      static __wrap(ptr) {
-        ptr = ptr >>> 0;
-        const obj = Object.create(_HexConfig.prototype);
-        obj.__wbg_ptr = ptr;
-        HexConfigFinalization.register(obj, obj.__wbg_ptr, obj);
-        return obj;
-      }
-      __destroy_into_raw() {
-        const ptr = this.__wbg_ptr;
-        this.__wbg_ptr = 0;
-        HexConfigFinalization.unregister(this);
-        return ptr;
-      }
-      free() {
-        const ptr = this.__destroy_into_raw();
-        wasm.__wbg_hexconfig_free(ptr, 0);
-      }
-      /**
-       * Hexagon orientation
-       * @returns {HexOrientation}
-       */
-      get orientation() {
-        const ret = wasm.__wbg_get_hexconfig_orientation(this.__wbg_ptr);
-        return ret;
-      }
-      /**
-       * Hexagon orientation
-       * @param {HexOrientation} arg0
-       */
-      set orientation(arg0) {
-        wasm.__wbg_set_hexconfig_orientation(this.__wbg_ptr, arg0);
-      }
-      /**
-       * Draw hexagon borders
-       * @returns {boolean}
-       */
-      get draw_borders() {
-        const ret = wasm.__wbg_get_hexconfig_draw_borders(this.__wbg_ptr);
-        return ret !== 0;
-      }
-      /**
-       * Draw hexagon borders
-       * @param {boolean} arg0
-       */
-      set draw_borders(arg0) {
-        wasm.__wbg_set_hexconfig_draw_borders(this.__wbg_ptr, arg0);
-      }
-      /**
-       * Border color (RGBA packed as u32: 0xRRGGBBAA)
-       * @returns {number}
-       */
-      get border_color() {
-        const ret = wasm.__wbg_get_hexconfig_border_color(this.__wbg_ptr);
-        return ret >>> 0;
-      }
-      /**
-       * Border color (RGBA packed as u32: 0xRRGGBBAA)
-       * @param {number} arg0
-       */
-      set border_color(arg0) {
-        wasm.__wbg_set_hexconfig_border_color(this.__wbg_ptr, arg0);
-      }
-      /**
-       * Border thickness in pixels
-       * @returns {number}
-       */
-      get border_thickness() {
-        const ret = wasm.__wbg_get_hexconfig_border_thickness(this.__wbg_ptr);
-        return ret >>> 0;
-      }
-      /**
-       * Border thickness in pixels
-       * @param {number} arg0
-       */
-      set border_thickness(arg0) {
-        wasm.__wbg_set_hexconfig_border_thickness(this.__wbg_ptr, arg0);
-      }
-      /**
-       * Background color (RGBA packed as u32)
-       * @returns {number}
-       */
-      get background_color() {
-        const ret = wasm.__wbg_get_hexconfig_background_color(this.__wbg_ptr);
-        return ret >>> 0;
-      }
-      /**
-       * Background color (RGBA packed as u32)
-       * @param {number} arg0
-       */
-      set background_color(arg0) {
-        wasm.__wbg_set_hexconfig_background_color(this.__wbg_ptr, arg0);
-      }
-      constructor() {
-        const ret = wasm.hexconfig_new();
-        this.__wbg_ptr = ret >>> 0;
-        HexConfigFinalization.register(this, this.__wbg_ptr, this);
-        return this;
-      }
-      /**
-       * Create preset with borders
-       * @returns {HexConfig}
-       */
-      static preset_bordered() {
-        const ret = wasm.hexconfig_preset_bordered();
-        return _HexConfig.__wrap(ret);
-      }
-      /**
-       * Create preset for pointy-top hexagons
-       * @returns {HexConfig}
-       */
-      static preset_pointy() {
-        const ret = wasm.hexconfig_preset_pointy();
-        return _HexConfig.__wrap(ret);
-      }
-    };
-    if (Symbol.dispose) HexConfig.prototype[Symbol.dispose] = HexConfig.prototype.free;
-    HexOrientation = Object.freeze({
-      /**
-       * Flat edge at top, vertices on left/right
-       */
-      FlatTop: 0,
-      "0": "FlatTop",
-      /**
-       * Vertex at top, flat edges on left/right
-       */
-      PointyTop: 1,
-      "1": "PointyTop"
-    });
-    UpscaleResult = class _UpscaleResult {
-      static __wrap(ptr) {
-        ptr = ptr >>> 0;
-        const obj = Object.create(_UpscaleResult.prototype);
-        obj.__wbg_ptr = ptr;
-        UpscaleResultFinalization.register(obj, obj.__wbg_ptr, obj);
-        return obj;
-      }
-      __destroy_into_raw() {
-        const ptr = this.__wbg_ptr;
-        this.__wbg_ptr = 0;
-        UpscaleResultFinalization.unregister(this);
-        return ptr;
-      }
-      free() {
-        const ptr = this.__destroy_into_raw();
-        wasm.__wbg_upscaleresult_free(ptr, 0);
-      }
-      /**
-       * Pointer to the output buffer in WASM memory
-       * @returns {number}
-       */
-      get ptr() {
-        const ret = wasm.upscaleresult_ptr(this.__wbg_ptr);
-        return ret >>> 0;
-      }
-      /**
-       * Length of the output buffer in bytes
-       * @returns {number}
-       */
-      get len() {
-        const ret = wasm.upscaleresult_len(this.__wbg_ptr);
-        return ret >>> 0;
-      }
-      /**
-       * Output image width
-       * @returns {number}
-       */
-      get width() {
-        const ret = wasm.upscaleresult_width(this.__wbg_ptr);
-        return ret >>> 0;
-      }
-      /**
-       * Output image height
-       * @returns {number}
-       */
-      get height() {
-        const ret = wasm.upscaleresult_height(this.__wbg_ptr);
-        return ret >>> 0;
-      }
-    };
-    if (Symbol.dispose) UpscaleResult.prototype[Symbol.dispose] = UpscaleResult.prototype.free;
-    XbrzConfig = class _XbrzConfig {
-      static __wrap(ptr) {
-        ptr = ptr >>> 0;
-        const obj = Object.create(_XbrzConfig.prototype);
-        obj.__wbg_ptr = ptr;
-        XbrzConfigFinalization.register(obj, obj.__wbg_ptr, obj);
-        return obj;
-      }
-      __destroy_into_raw() {
-        const ptr = this.__wbg_ptr;
-        this.__wbg_ptr = 0;
-        XbrzConfigFinalization.unregister(this);
-        return ptr;
-      }
-      free() {
-        const ptr = this.__destroy_into_raw();
-        wasm.__wbg_xbrzconfig_free(ptr, 0);
-      }
-      /**
-       * Luminance weight for edge detection (0.0 - 1.0)
-       * @returns {number}
-       */
-      get luminance_weight() {
-        const ret = wasm.__wbg_get_crtconfig_warp_x(this.__wbg_ptr);
-        return ret;
-      }
-      /**
-       * Luminance weight for edge detection (0.0 - 1.0)
-       * @param {number} arg0
-       */
-      set luminance_weight(arg0) {
-        wasm.__wbg_set_crtconfig_warp_x(this.__wbg_ptr, arg0);
-      }
-      /**
-       * Equal color tolerance (0 - 50)
-       * @returns {number}
-       */
-      get equal_color_tolerance() {
-        const ret = wasm.__wbg_get_hexconfig_border_thickness(this.__wbg_ptr);
-        return ret >>> 0;
-      }
-      /**
-       * Equal color tolerance (0 - 50)
-       * @param {number} arg0
-       */
-      set equal_color_tolerance(arg0) {
-        wasm.__wbg_set_hexconfig_border_thickness(this.__wbg_ptr, arg0);
-      }
-      /**
-       * Dominant direction threshold (3.5 - 6.0)
-       * @returns {number}
-       */
-      get dominant_direction_threshold() {
-        const ret = wasm.__wbg_get_crtconfig_scan_hardness(this.__wbg_ptr);
-        return ret;
-      }
-      /**
-       * Dominant direction threshold (3.5 - 6.0)
-       * @param {number} arg0
-       */
-      set dominant_direction_threshold(arg0) {
-        wasm.__wbg_set_crtconfig_scan_hardness(this.__wbg_ptr, arg0);
-      }
-      /**
-       * Steep direction threshold (2.0 - 3.0)
-       * @returns {number}
-       */
-      get steep_direction_threshold() {
-        const ret = wasm.__wbg_get_crtconfig_scan_opacity(this.__wbg_ptr);
-        return ret;
-      }
-      /**
-       * Steep direction threshold (2.0 - 3.0)
-       * @param {number} arg0
-       */
-      set steep_direction_threshold(arg0) {
-        wasm.__wbg_set_crtconfig_scan_opacity(this.__wbg_ptr, arg0);
-      }
-      constructor() {
-        const ret = wasm.xbrzconfig_new();
-        this.__wbg_ptr = ret >>> 0;
-        XbrzConfigFinalization.register(this, this.__wbg_ptr, this);
-        return this;
-      }
-      /**
-       * Preset for sharp edges
-       * @returns {XbrzConfig}
-       */
-      static preset_sharp() {
-        const ret = wasm.xbrzconfig_preset_sharp();
-        return _XbrzConfig.__wrap(ret);
-      }
-      /**
-       * Preset for smooth output
-       * @returns {XbrzConfig}
-       */
-      static preset_smooth() {
-        const ret = wasm.xbrzconfig_preset_smooth();
-        return _XbrzConfig.__wrap(ret);
-      }
-    };
-    if (Symbol.dispose) XbrzConfig.prototype[Symbol.dispose] = XbrzConfig.prototype.free;
-    EXPECTED_RESPONSE_TYPES = /* @__PURE__ */ new Set(["basic", "cors", "default"]);
-    renderart_wasm_default = __wbg_init;
-  }
-});
-
 // src/crt-gpu.ts
 var VERTEX_SHADER = `#version 300 es
 layout(location = 0) in vec2 position;
@@ -1410,31 +620,85 @@ var HEX_PRESETS = {
 };
 
 // src/wasm-loader.ts
-var wasmModule = null;
+var wasm = null;
 var wasmMemory = null;
-var loadPromise = null;
-async function loadWasm() {
-  if (wasmModule) return wasmModule;
-  if (loadPromise) return loadPromise;
-  loadPromise = (async () => {
+var initPromise = null;
+var wasmUrl = "";
+var cachedUint8Memory = null;
+var WASM_VECTOR_LEN = 0;
+function getUint8Memory() {
+  if (cachedUint8Memory === null || cachedUint8Memory.byteLength === 0) {
+    cachedUint8Memory = new Uint8Array(wasmMemory.buffer);
+  }
+  return cachedUint8Memory;
+}
+function passArray8ToWasm(arg) {
+  const ptr = wasm.__wbindgen_malloc(arg.length);
+  getUint8Memory().set(arg, ptr);
+  WASM_VECTOR_LEN = arg.length;
+  return ptr;
+}
+function setWasmUrl(url) {
+  wasmUrl = url;
+}
+function getDefaultWasmUrl() {
+  if (wasmUrl) return wasmUrl;
+  const paths = [
+    "/renderart_wasm_bg.wasm",
+    "/wasm/renderart_wasm_bg.wasm",
+    "/static/wasm/renderart_wasm_bg.wasm",
+    "/assets/wasm/renderart_wasm_bg.wasm"
+  ];
+  return paths[0];
+}
+async function initWasm(customUrl) {
+  if (wasm) return;
+  if (initPromise) return initPromise;
+  const url = customUrl || getDefaultWasmUrl();
+  initPromise = (async () => {
     try {
-      const wasm2 = await Promise.resolve().then(() => (init_renderart_wasm(), renderart_wasm_exports));
-      await wasm2.default();
-      wasmModule = wasm2;
-      wasmMemory = wasmModule.get_memory();
-      return wasmModule;
+      const response = await fetch(url);
+      if (!response.ok) {
+        throw new Error(`Failed to fetch WASM: ${response.status} ${response.statusText}`);
+      }
+      const bytes = await response.arrayBuffer();
+      const imports = {
+        __wbindgen_placeholder__: {
+          __wbindgen_throw: (ptr, len) => {
+            const msg = new TextDecoder().decode(getUint8Memory().subarray(ptr, ptr + len));
+            throw new Error(msg);
+          }
+        },
+        wbg: {
+          __wbindgen_throw: (ptr, len) => {
+            const msg = new TextDecoder().decode(getUint8Memory().subarray(ptr, ptr + len));
+            throw new Error(msg);
+          }
+        }
+      };
+      const { instance } = await WebAssembly.instantiate(bytes, imports);
+      wasm = instance.exports;
+      wasmMemory = wasm.memory;
+      if (wasm.__wbindgen_start) {
+        wasm.__wbindgen_start();
+      }
     } catch (e) {
-      throw new Error(`Failed to load WASM module: ${e}`);
+      initPromise = null;
+      throw new Error(`Failed to initialize WASM: ${e}. Make sure the .wasm file is served at: ${url}`);
     }
   })();
-  return loadPromise;
+  return initPromise;
 }
 function isWasmLoaded() {
-  return wasmModule !== null;
+  return wasm !== null;
+}
+async function ensureWasm() {
+  if (!wasm) {
+    await initWasm();
+  }
 }
-function getOutputData(result) {
-  if (!wasmMemory) throw new Error("WASM memory not available");
-  const buffer = new Uint8Array(wasmMemory.buffer, result.ptr, result.len);
+function getOutputData(ptr, len) {
+  const buffer = getUint8Memory().subarray(ptr, ptr + len);
   return new Uint8ClampedArray(buffer.slice());
 }
 function toUint8Array(input) {
@@ -1460,46 +724,49 @@ var CrtCpuRenderer = class _CrtCpuRenderer {
   constructor() {
     this.ready = false;
   }
-  /** Create and initialize renderer */
+  /** Create and initialize renderer (auto-loads WASM) */
   static async create() {
+    await ensureWasm();
     const renderer = new _CrtCpuRenderer();
-    await renderer.init();
+    renderer.ready = true;
     return renderer;
   }
-  async init() {
-    await loadWasm();
-    this.ready = true;
-  }
-  /** Check if renderer is ready */
   isReady() {
-    return this.ready;
+    return this.ready && isWasmLoaded();
   }
-  /** Render CRT effect */
   render(input, options = {}) {
-    if (!this.ready || !wasmModule) {
+    if (!this.ready || !wasm) {
       throw new Error("Renderer not initialized");
     }
     const data = toUint8Array(input);
     const width = input.width;
     const height = input.height;
     const scale = Math.min(32, Math.max(2, options.scale ?? 3));
-    const config = new wasmModule.CrtConfig();
-    config.warp_x = options.warpX ?? 0.015;
-    config.warp_y = options.warpY ?? 0.02;
-    config.scan_hardness = options.scanHardness ?? -4;
-    config.scan_opacity = options.scanOpacity ?? 0.5;
-    config.mask_opacity = options.maskOpacity ?? 0.3;
-    config.enable_warp = options.enableWarp !== false;
-    config.enable_scanlines = options.enableScanlines !== false;
-    config.enable_mask = options.enableMask !== false;
-    const result = wasmModule.crt_upscale_config(data, width, height, scale, config);
+    const ptr = passArray8ToWasm(data);
+    const resultPtr = wasm.crt_upscale_raw(
+      ptr,
+      WASM_VECTOR_LEN,
+      width,
+      height,
+      scale,
+      options.warpX ?? 0.015,
+      options.warpY ?? 0.02,
+      options.scanHardness ?? -4,
+      options.scanOpacity ?? 0.5,
+      options.maskOpacity ?? 0.3,
+      options.enableWarp !== false ? 1 : 0,
+      options.enableScanlines !== false ? 1 : 0,
+      options.enableMask !== false ? 1 : 0
+    );
+    const outWidth = width * scale;
+    const outHeight = height * scale;
+    const outLen = outWidth * outHeight * 4;
     return {
-      data: getOutputData(result),
-      width: result.width,
-      height: result.height
+      data: getOutputData(resultPtr, outLen),
+      width: outWidth,
+      height: outHeight
     };
   }
-  /** Dispose resources */
   dispose() {
     this.ready = false;
   }
@@ -1508,51 +775,68 @@ var HexCpuRenderer = class _HexCpuRenderer {
   constructor() {
     this.ready = false;
   }
-  /** Create and initialize renderer */
   static async create() {
+    await ensureWasm();
     const renderer = new _HexCpuRenderer();
-    await renderer.init();
+    renderer.ready = true;
     return renderer;
   }
-  async init() {
-    await loadWasm();
-    this.ready = true;
-  }
-  /** Check if renderer is ready */
   isReady() {
-    return this.ready;
+    return this.ready && isWasmLoaded();
   }
-  /** Render hexagonal effect */
   render(input, options = {}) {
-    if (!this.ready || !wasmModule) {
+    if (!this.ready || !wasm) {
       throw new Error("Renderer not initialized");
     }
     const data = toUint8Array(input);
     const width = input.width;
     const height = input.height;
     const scale = Math.min(32, Math.max(2, options.scale ?? 16));
-    const config = new wasmModule.HexConfig();
-    config.orientation = options.orientation === "pointy-top" ? 1 : 0;
-    config.draw_borders = options.drawBorders ?? false;
-    config.border_color = parseColorToU32(options.borderColor, 673720575);
-    config.border_thickness = options.borderThickness ?? 1;
-    config.background_color = parseColorToU32(options.backgroundColor, 0);
-    const result = wasmModule.hex_upscale_config(data, width, height, scale, config);
+    const orientation = options.orientation === "pointy-top" ? 1 : 0;
+    const ptr = passArray8ToWasm(data);
+    const resultPtr = wasm.hex_upscale_raw(
+      ptr,
+      WASM_VECTOR_LEN,
+      width,
+      height,
+      scale,
+      orientation,
+      options.drawBorders ? 1 : 0,
+      parseColorToU32(options.borderColor, 673720575),
+      options.borderThickness ?? 1,
+      parseColorToU32(options.backgroundColor, 0)
+    );
+    const dims = this.getDimensions(width, height, scale, options.orientation);
+    const outLen = dims.width * dims.height * 4;
     return {
-      data: getOutputData(result),
-      width: result.width,
-      height: result.height
+      data: getOutputData(resultPtr, outLen),
+      width: dims.width,
+      height: dims.height
     };
   }
-  /** Get output dimensions */
   getDimensions(srcWidth, srcHeight, scale, orientation = "flat-top") {
-    if (!this.ready || !wasmModule) {
-      throw new Error("Renderer not initialized");
+    const SQRT3 = 1.732050808;
+    scale = Math.min(32, Math.max(2, scale));
+    if (orientation === "flat-top") {
+      const hSpacing = scale * 1.5;
+      const vSpacing = scale * SQRT3;
+      const cellWidth = scale * 2;
+      const cellHeight = scale * SQRT3;
+      return {
+        width: Math.ceil(srcWidth * hSpacing + cellWidth),
+        height: Math.ceil(srcHeight * vSpacing + cellHeight)
+      };
+    } else {
+      const hSpacing = scale * SQRT3;
+      const vSpacing = scale * 1.5;
+      const cellWidth = scale * SQRT3;
+      const cellHeight = scale * 2;
+      return {
+        width: Math.ceil(srcWidth * hSpacing + cellWidth),
+        height: Math.ceil(srcHeight * vSpacing + cellHeight)
+      };
     }
-    const dims = wasmModule.hex_get_dimensions(srcWidth, srcHeight, scale, orientation === "pointy-top" ? 1 : 0);
-    return { width: dims[0], height: dims[1] };
   }
-  /** Dispose resources */
   dispose() {
     this.ready = false;
   }
@@ -1561,42 +845,44 @@ var XbrzCpuRenderer = class _XbrzCpuRenderer {
   constructor() {
     this.ready = false;
   }
-  /** Create and initialize renderer */
   static async create() {
+    await ensureWasm();
     const renderer = new _XbrzCpuRenderer();
-    await renderer.init();
+    renderer.ready = true;
     return renderer;
   }
-  async init() {
-    await loadWasm();
-    this.ready = true;
-  }
-  /** Check if renderer is ready */
   isReady() {
-    return this.ready;
+    return this.ready && isWasmLoaded();
   }
-  /** Render xBRZ scaling */
   render(input, options = {}) {
-    if (!this.ready || !wasmModule) {
+    if (!this.ready || !wasm) {
       throw new Error("Renderer not initialized");
     }
     const data = toUint8Array(input);
     const width = input.width;
     const height = input.height;
     const scale = Math.min(6, Math.max(2, options.scale ?? 2));
-    const config = new wasmModule.XbrzConfig();
-    config.luminance_weight = options.luminanceWeight ?? 1;
-    config.equal_color_tolerance = options.equalColorTolerance ?? 30;
-    config.dominant_direction_threshold = options.dominantDirectionThreshold ?? 4.4;
-    config.steep_direction_threshold = options.steepDirectionThreshold ?? 2.2;
-    const result = wasmModule.xbrz_upscale_config(data, width, height, scale, config);
+    const ptr = passArray8ToWasm(data);
+    const resultPtr = wasm.xbrz_upscale_raw(
+      ptr,
+      WASM_VECTOR_LEN,
+      width,
+      height,
+      scale,
+      options.luminanceWeight ?? 1,
+      options.equalColorTolerance ?? 30,
+      options.dominantDirectionThreshold ?? 4.4,
+      options.steepDirectionThreshold ?? 2.2
+    );
+    const outWidth = width * scale;
+    const outHeight = height * scale;
+    const outLen = outWidth * outHeight * 4;
     return {
-      data: getOutputData(result),
-      width: result.width,
-      height: result.height
+      data: getOutputData(resultPtr, outLen),
+      width: outWidth,
+      height: outHeight
     };
   }
-  /** Dispose resources */
   dispose() {
     this.ready = false;
   }
@@ -1638,13 +924,11 @@ function getMaxTextureSize() {
   }
 }
 var CrtEngine = class {
-  constructor(gpuAvailable, cpuAvailable) {
+  constructor(gpuAvailable) {
     this.gpuRenderer = null;
     this.cpuRenderer = null;
     this.gpuAvailable = gpuAvailable;
-    this.cpuAvailable = cpuAvailable;
   }
-  /** Initialize GPU renderer */
   ensureGpu() {
     if (!this.gpuRenderer && this.gpuAvailable) {
       this.gpuRenderer = CrtGpuRenderer.create();
@@ -1652,12 +936,10 @@ var CrtEngine = class {
     if (!this.gpuRenderer) throw new Error("GPU renderer not available");
     return this.gpuRenderer;
   }
-  /** Initialize CPU renderer */
   async ensureCpu() {
-    if (!this.cpuRenderer && this.cpuAvailable) {
+    if (!this.cpuRenderer) {
       this.cpuRenderer = await CrtCpuRenderer.create();
     }
-    if (!this.cpuRenderer) throw new Error("CPU renderer not available");
     return this.cpuRenderer;
   }
   async render(input, optionsOrPreset, overrides) {
@@ -1682,7 +964,6 @@ var CrtEngine = class {
   renderSync(input, options) {
     return this.ensureGpu().render(input, options ?? {});
   }
-  /** Dispose resources */
   dispose() {
     this.gpuRenderer?.dispose();
     this.cpuRenderer?.dispose();
@@ -1691,11 +972,10 @@ var CrtEngine = class {
   }
 };
 var HexEngine = class {
-  constructor(gpuAvailable, cpuAvailable) {
+  constructor(gpuAvailable) {
     this.gpuRenderer = null;
     this.cpuRenderer = null;
     this.gpuAvailable = gpuAvailable;
-    this.cpuAvailable = cpuAvailable;
   }
   ensureGpu() {
     if (!this.gpuRenderer && this.gpuAvailable) {
@@ -1705,10 +985,9 @@ var HexEngine = class {
     return this.gpuRenderer;
   }
   async ensureCpu() {
-    if (!this.cpuRenderer && this.cpuAvailable) {
+    if (!this.cpuRenderer) {
       this.cpuRenderer = await HexCpuRenderer.create();
     }
-    if (!this.cpuRenderer) throw new Error("CPU renderer not available");
     return this.cpuRenderer;
   }
   async render(input, optionsOrPreset, overrides) {
@@ -1729,11 +1008,9 @@ var HexEngine = class {
     const cpu = await this.ensureCpu();
     return cpu.render(input, options);
   }
-  /** Render synchronously (GPU only) */
   renderSync(input, options) {
     return this.ensureGpu().render(input, options ?? {});
   }
-  /** Get output dimensions */
   getDimensions(srcWidth, srcHeight, options) {
     const scale = options?.scale ?? 16;
     const orientation = options?.orientation ?? "flat-top";
@@ -1747,15 +1024,13 @@ var HexEngine = class {
   }
 };
 var XbrzEngine = class {
-  constructor(cpuAvailable) {
+  constructor() {
     this.cpuRenderer = null;
-    this.cpuAvailable = cpuAvailable;
   }
   async ensureCpu() {
-    if (!this.cpuRenderer && this.cpuAvailable) {
+    if (!this.cpuRenderer) {
       this.cpuRenderer = await XbrzCpuRenderer.create();
     }
-    if (!this.cpuRenderer) throw new Error("CPU renderer not available");
     return this.cpuRenderer;
   }
   async render(input, optionsOrPreset, overrides) {
@@ -1768,7 +1043,6 @@ var XbrzEngine = class {
     const cpu = await this.ensureCpu();
     return cpu.render(input, options);
   }
-  /** Get output dimensions */
   getDimensions(srcWidth, srcHeight, scale = 2) {
     const s = Math.min(6, Math.max(2, scale));
     return { width: srcWidth * s, height: srcHeight * s };
@@ -1779,37 +1053,38 @@ var XbrzEngine = class {
   }
 };
 var RenderArt = class _RenderArt {
-  constructor(gpuAvailable, cpuAvailable) {
-    this.crt = new CrtEngine(gpuAvailable, cpuAvailable);
-    this.hex = new HexEngine(gpuAvailable, cpuAvailable);
-    this.xbrz = new XbrzEngine(cpuAvailable);
+  constructor(gpuAvailable) {
+    this.crt = new CrtEngine(gpuAvailable);
+    this.hex = new HexEngine(gpuAvailable);
+    this.xbrz = new XbrzEngine();
     const maxTextureSize = gpuAvailable ? getMaxTextureSize() : 0;
     this._capabilities = {
       gpu: gpuAvailable,
-      cpu: cpuAvailable,
+      cpu: true,
+      // Always potentially available via async init
       maxTextureSize,
-      recommendedBackend: gpuAvailable ? "gpu" : cpuAvailable ? "cpu" : "auto"
+      recommendedBackend: gpuAvailable ? "gpu" : "cpu"
     };
   }
-  /** Create and initialize RenderArt instance */
-  static async create() {
+  /** Create RenderArt instance */
+  static create() {
     const gpuAvailable = checkWebGL2();
-    let cpuAvailable = false;
-    try {
-      await loadWasm();
-      cpuAvailable = isWasmLoaded();
-    } catch {
-    }
-    if (!gpuAvailable && !cpuAvailable) {
-      throw new Error("No rendering backend available. WebGL2 or WASM required.");
+    return new _RenderArt(gpuAvailable);
+  }
+  /** Create GPU-only instance */
+  static createGpuOnly() {
+    if (!checkWebGL2()) {
+      throw new Error("WebGL2 not supported");
     }
-    return new _RenderArt(gpuAvailable, cpuAvailable);
+    return new _RenderArt(true);
+  }
+  /** Pre-initialize WASM for faster first CPU render */
+  async preloadWasm(wasmUrl2) {
+    await initWasm(wasmUrl2);
   }
-  /** Get renderer capabilities */
   get capabilities() {
     return { ...this._capabilities };
   }
-  /** Dispose all resources */
   dispose() {
     this.crt.dispose();
     this.hex.dispose();
@@ -1819,15 +1094,19 @@ var RenderArt = class _RenderArt {
 
 exports.CRT_PRESETS = CRT_PRESETS;
 exports.CrtCpuRenderer = CrtCpuRenderer;
+exports.CrtEngine = CrtEngine;
 exports.CrtGpuRenderer = CrtGpuRenderer;
 exports.HEX_PRESETS = HEX_PRESETS;
 exports.HexCpuRenderer = HexCpuRenderer;
+exports.HexEngine = HexEngine;
 exports.HexGpuRenderer = HexGpuRenderer;
 exports.RenderArt = RenderArt;
 exports.XBRZ_PRESETS = XBRZ_PRESETS;
 exports.XbrzCpuRenderer = XbrzCpuRenderer;
+exports.XbrzEngine = XbrzEngine;
 exports.hexGetDimensions = hexGetDimensions;
+exports.initWasm = initWasm;
 exports.isWasmLoaded = isWasmLoaded;
-exports.loadWasm = loadWasm;
+exports.setWasmUrl = setWasmUrl;
 //# sourceMappingURL=index.js.map
 //# sourceMappingURL=index.js.map