@pixagram/renderart 0.1.2 → 0.2.0

package/dist/index.mjs

@@ -1,792 +1,3 @@
-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", 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);
-}
-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;
@@ -1409,26 +620,33 @@ var HEX_PRESETS = {
 // src/wasm-loader.ts
 var wasmModule = null;
 var wasmMemory = null;
-var loadPromise = null;
-async function loadWasm() {
-  if (wasmModule) return wasmModule;
-  if (loadPromise) return loadPromise;
-  loadPromise = (async () => {
+var initPromise = null;
+async function initWasm(wasmInit, wasm) {
+  if (wasmModule) return;
+  if (initPromise) return initPromise;
+  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;
+      await wasmInit();
+      wasmModule = wasm;
+      if (wasmModule.get_memory) {
+        wasmMemory = wasmModule.get_memory();
+      }
     } catch (e) {
-      throw new Error(`Failed to load WASM module: ${e}`);
+      initPromise = null;
+      throw new Error(`Failed to initialize WASM module: ${e}`);
     }
   })();
-  return loadPromise;
+  return initPromise;
 }
 function isWasmLoaded() {
   return wasmModule !== null;
 }
+function getWasmModule() {
+  if (!wasmModule) {
+    throw new Error("WASM not initialized. Call initWasm() first.");
+  }
+  return wasmModule;
+}
 function getOutputData(result) {
   if (!wasmMemory) throw new Error("WASM memory not available");
   const buffer = new Uint8Array(wasmMemory.buffer, result.ptr, result.len);
@@ -1457,19 +675,18 @@ var CrtCpuRenderer = class _CrtCpuRenderer {
   constructor() {
     this.ready = false;
   }
-  /** Create and initialize renderer */
-  static async create() {
+  /** Create renderer (WASM must be initialized first via initWasm) */
+  static create() {
+    if (!isWasmLoaded()) {
+      throw new Error("WASM not initialized. Call initWasm() first.");
+    }
     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 = {}) {
@@ -1505,19 +722,18 @@ var HexCpuRenderer = class _HexCpuRenderer {
   constructor() {
     this.ready = false;
   }
-  /** Create and initialize renderer */
-  static async create() {
+  /** Create renderer (WASM must be initialized first via initWasm) */
+  static create() {
+    if (!isWasmLoaded()) {
+      throw new Error("WASM not initialized. Call initWasm() first.");
+    }
     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 = {}) {
@@ -1558,19 +774,18 @@ var XbrzCpuRenderer = class _XbrzCpuRenderer {
   constructor() {
     this.ready = false;
   }
-  /** Create and initialize renderer */
-  static async create() {
+  /** Create renderer (WASM must be initialized first via initWasm) */
+  static create() {
+    if (!isWasmLoaded()) {
+      throw new Error("WASM not initialized. Call initWasm() first.");
+    }
     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 = {}) {
@@ -1650,14 +865,14 @@ var CrtEngine = class {
     return this.gpuRenderer;
   }
   /** Initialize CPU renderer */
-  async ensureCpu() {
-    if (!this.cpuRenderer && this.cpuAvailable) {
-      this.cpuRenderer = await CrtCpuRenderer.create();
+  ensureCpu() {
+    if (!this.cpuRenderer && this.cpuAvailable && isWasmLoaded()) {
+      this.cpuRenderer = CrtCpuRenderer.create();
     }
-    if (!this.cpuRenderer) throw new Error("CPU renderer not available");
+    if (!this.cpuRenderer) throw new Error("CPU renderer not available. Initialize WASM first.");
     return this.cpuRenderer;
   }
-  async render(input, optionsOrPreset, overrides) {
+  render(input, optionsOrPreset, overrides) {
     let options = {};
     if (typeof optionsOrPreset === "string") {
       options = { ...CRT_PRESETS[optionsOrPreset], ...overrides };
@@ -1672,8 +887,7 @@ var CrtEngine = class {
         if (backend === "gpu") throw e;
       }
     }
-    const cpu = await this.ensureCpu();
-    return cpu.render(input, options);
+    return this.ensureCpu().render(input, options);
   }
   /** Render synchronously (GPU only) */
   renderSync(input, options) {
@@ -1701,14 +915,14 @@ var HexEngine = class {
     if (!this.gpuRenderer) throw new Error("GPU renderer not available");
     return this.gpuRenderer;
   }
-  async ensureCpu() {
-    if (!this.cpuRenderer && this.cpuAvailable) {
-      this.cpuRenderer = await HexCpuRenderer.create();
+  ensureCpu() {
+    if (!this.cpuRenderer && this.cpuAvailable && isWasmLoaded()) {
+      this.cpuRenderer = HexCpuRenderer.create();
     }
-    if (!this.cpuRenderer) throw new Error("CPU renderer not available");
+    if (!this.cpuRenderer) throw new Error("CPU renderer not available. Initialize WASM first.");
     return this.cpuRenderer;
   }
-  async render(input, optionsOrPreset, overrides) {
+  render(input, optionsOrPreset, overrides) {
     let options = {};
     if (typeof optionsOrPreset === "string") {
       options = { ...HEX_PRESETS[optionsOrPreset], ...overrides };
@@ -1723,8 +937,7 @@ var HexEngine = class {
         if (backend === "gpu") throw e;
       }
     }
-    const cpu = await this.ensureCpu();
-    return cpu.render(input, options);
+    return this.ensureCpu().render(input, options);
   }
   /** Render synchronously (GPU only) */
   renderSync(input, options) {
@@ -1748,22 +961,21 @@ var XbrzEngine = class {
     this.cpuRenderer = null;
     this.cpuAvailable = cpuAvailable;
   }
-  async ensureCpu() {
-    if (!this.cpuRenderer && this.cpuAvailable) {
-      this.cpuRenderer = await XbrzCpuRenderer.create();
+  ensureCpu() {
+    if (!this.cpuRenderer && this.cpuAvailable && isWasmLoaded()) {
+      this.cpuRenderer = XbrzCpuRenderer.create();
     }
-    if (!this.cpuRenderer) throw new Error("CPU renderer not available");
+    if (!this.cpuRenderer) throw new Error("CPU renderer not available. Initialize WASM first.");
     return this.cpuRenderer;
   }
-  async render(input, optionsOrPreset, overrides) {
+  render(input, optionsOrPreset, overrides) {
     let options = {};
     if (typeof optionsOrPreset === "string") {
       options = { ...XBRZ_PRESETS[optionsOrPreset], ...overrides };
     } else if (optionsOrPreset) {
       options = optionsOrPreset;
     }
-    const cpu = await this.ensureCpu();
-    return cpu.render(input, options);
+    return this.ensureCpu().render(input, options);
   }
   /** Get output dimensions */
   getDimensions(srcWidth, srcHeight, scale = 2) {
@@ -1788,20 +1000,30 @@ var RenderArt = class _RenderArt {
       recommendedBackend: gpuAvailable ? "gpu" : cpuAvailable ? "cpu" : "auto"
     };
   }
-  /** Create and initialize RenderArt instance */
-  static async create() {
+  /** 
+   * Create RenderArt instance
+   * GPU renderers always available if WebGL2 supported.
+   * CPU renderers require WASM to be initialized via initWasm() first.
+   */
+  static create() {
     const gpuAvailable = checkWebGL2();
-    let cpuAvailable = false;
-    try {
-      await loadWasm();
-      cpuAvailable = isWasmLoaded();
-    } catch {
-    }
+    const cpuAvailable = isWasmLoaded();
     if (!gpuAvailable && !cpuAvailable) {
-      throw new Error("No rendering backend available. WebGL2 or WASM required.");
+      throw new Error("No rendering backend available. WebGL2 not supported and WASM not initialized.");
     }
     return new _RenderArt(gpuAvailable, cpuAvailable);
   }
+  /**
+   * Create GPU-only RenderArt instance (no WASM required)
+   * CPU fallback will not be available.
+   */
+  static createGpuOnly() {
+    const gpuAvailable = checkWebGL2();
+    if (!gpuAvailable) {
+      throw new Error("WebGL2 not supported");
+    }
+    return new _RenderArt(true, false);
+  }
   /** Get renderer capabilities */
   get capabilities() {
     return { ...this._capabilities };
@@ -1814,6 +1036,6 @@ var RenderArt = class _RenderArt {
   }
 };
 
-export { CRT_PRESETS, CrtCpuRenderer, CrtGpuRenderer, HEX_PRESETS, HexCpuRenderer, HexGpuRenderer, RenderArt, XBRZ_PRESETS, XbrzCpuRenderer, hexGetDimensions, isWasmLoaded, loadWasm };
+export { CRT_PRESETS, CrtCpuRenderer, CrtEngine, CrtGpuRenderer, HEX_PRESETS, HexCpuRenderer, HexEngine, HexGpuRenderer, RenderArt, XBRZ_PRESETS, XbrzCpuRenderer, XbrzEngine, getWasmModule, hexGetDimensions, initWasm, isWasmLoaded };
 //# sourceMappingURL=index.mjs.map
 //# sourceMappingURL=index.mjs.map