@pixagram/renderart 0.1.0

package/dist/index.mjs

@@ -0,0 +1,1819 @@
+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;
+out vec2 vUv;
+
+void main() {
+    vUv = position * 0.5 + 0.5;
+    gl_Position = vec4(position, 0.0, 1.0);
+}`;
+var FRAGMENT_SHADER = `#version 300 es
+precision highp float;
+
+uniform sampler2D uTex;
+uniform vec2 uRes;
+uniform vec2 uWarp;
+uniform float uScanHardness;
+uniform float uScanOpacity;
+uniform float uMaskOpacity;
+uniform int uEnableWarp;
+uniform int uEnableScanlines;
+uniform int uEnableMask;
+
+in vec2 vUv;
+out vec4 outColor;
+
+// Gamma 2.0 approximation
+vec3 toLinear(vec3 c) { return c * c; }
+vec3 toSrgb(vec3 c) { return sqrt(c); }
+
+vec2 warp(vec2 uv) {
+    if (uEnableWarp == 0) return uv;
+    vec2 dc = abs(0.5 - uv);
+    vec2 dc2 = dc * dc;
+    uv.x -= 0.5; uv.x *= 1.0 + (dc2.y * (0.3 * uWarp.x)); uv.x += 0.5;
+    uv.y -= 0.5; uv.y *= 1.0 + (dc2.x * (0.4 * uWarp.y)); uv.y += 0.5;
+    return uv;
+}
+
+float scanline(float y, float sourceHeight) {
+    if (uEnableScanlines == 0) return 1.0;
+    float v = fract(y * sourceHeight);
+    float d = abs(v - 0.5);
+    float line = exp(d * d * uScanHardness);
+    return mix(1.0, line, uScanOpacity);
+}
+
+vec3 mask(vec2 pos) {
+    if (uEnableMask == 0) return vec3(1.0);
+    float x = fract(pos.x / 6.0);
+    vec3 m = vec3(1.0);
+    float step1 = 0.333;
+    float step2 = 0.666;
+    
+    m.r = step(0.0, x) - step(step1, x);
+    m.g = step(step1, x) - step(step2, x);
+    m.b = step(step2, x) - step(1.0, x);
+    
+    return mix(vec3(1.0), m, uMaskOpacity);
+}
+
+void main() {
+    // 1. Geometry
+    vec2 uv = warp(vUv);
+    
+    // 2. Bounds Check
+    if (uv.x < 0.0 || uv.x > 1.0 || uv.y < 0.0 || uv.y > 1.0) {
+        outColor = vec4(0.0); 
+        return;
+    }
+
+    // 3. Texture Sample
+    vec4 texSample = texture(uTex, uv);
+    
+    if (texSample.a == 0.0) {
+        outColor = vec4(0.0);
+        return;
+    }
+
+    vec3 linearColor = toLinear(texSample.rgb);
+    
+    // 4. CRT Effects
+    ivec2 texSize = textureSize(uTex, 0);
+    
+    // Smart Bloom
+    float luma = dot(linearColor, vec3(0.299, 0.587, 0.114));
+    float bloom = luma * 0.7;
+
+    // Calculate patterns
+    float scan = scanline(uv.y, float(texSize.y));
+    vec3 m = mask(gl_FragCoord.xy);
+    
+    // Apply effects
+    vec3 effects = m * scan;
+    vec3 finalRGB = linearColor * mix(effects, vec3(1.0), bloom);
+
+    // 5. Output
+    outColor = vec4(toSrgb(finalRGB), texSample.a);
+}`;
+var CrtGpuRenderer = class _CrtGpuRenderer {
+  constructor() {
+    this.gl = null;
+    this.canvas = null;
+    this.program = null;
+    this.texture = null;
+    this.uniforms = {};
+    this.initialized = false;
+    this.currentCanvasSize = { width: 0, height: 0 };
+    this.currentTexSize = { width: 0, height: 0 };
+  }
+  /** Create a new CRT GPU renderer */
+  static create() {
+    const renderer = new _CrtGpuRenderer();
+    renderer.init();
+    return renderer;
+  }
+  init() {
+    if (typeof OffscreenCanvas === "undefined") {
+      throw new Error("OffscreenCanvas not supported");
+    }
+    this.canvas = new OffscreenCanvas(1, 1);
+    this.gl = this.canvas.getContext("webgl2", {
+      alpha: true,
+      premultipliedAlpha: false,
+      desynchronized: true,
+      powerPreference: "high-performance",
+      antialias: false
+    });
+    if (!this.gl) {
+      throw new Error("WebGL2 not supported");
+    }
+    const gl = this.gl;
+    const vs = this.createShader(gl.VERTEX_SHADER, VERTEX_SHADER);
+    const fs = this.createShader(gl.FRAGMENT_SHADER, FRAGMENT_SHADER);
+    this.program = gl.createProgram();
+    gl.attachShader(this.program, vs);
+    gl.attachShader(this.program, fs);
+    gl.linkProgram(this.program);
+    if (!gl.getProgramParameter(this.program, gl.LINK_STATUS)) {
+      throw new Error("Shader program link failed: " + gl.getProgramInfoLog(this.program));
+    }
+    gl.useProgram(this.program);
+    this.uniforms = {
+      uTex: gl.getUniformLocation(this.program, "uTex"),
+      uRes: gl.getUniformLocation(this.program, "uRes"),
+      uWarp: gl.getUniformLocation(this.program, "uWarp"),
+      uScanHardness: gl.getUniformLocation(this.program, "uScanHardness"),
+      uScanOpacity: gl.getUniformLocation(this.program, "uScanOpacity"),
+      uMaskOpacity: gl.getUniformLocation(this.program, "uMaskOpacity"),
+      uEnableWarp: gl.getUniformLocation(this.program, "uEnableWarp"),
+      uEnableScanlines: gl.getUniformLocation(this.program, "uEnableScanlines"),
+      uEnableMask: gl.getUniformLocation(this.program, "uEnableMask")
+    };
+    gl.uniform1i(this.uniforms.uTex, 0);
+    const buf = gl.createBuffer();
+    gl.bindBuffer(gl.ARRAY_BUFFER, buf);
+    gl.bufferData(gl.ARRAY_BUFFER, new Float32Array([-1, -1, 3, -1, -1, 3]), gl.STATIC_DRAW);
+    gl.enableVertexAttribArray(0);
+    gl.vertexAttribPointer(0, 2, gl.FLOAT, false, 0, 0);
+    this.texture = gl.createTexture();
+    gl.bindTexture(gl.TEXTURE_2D, this.texture);
+    gl.texParameteri(gl.TEXTURE_2D, gl.TEXTURE_MIN_FILTER, gl.LINEAR);
+    gl.texParameteri(gl.TEXTURE_2D, gl.TEXTURE_MAG_FILTER, gl.LINEAR);
+    gl.texParameteri(gl.TEXTURE_2D, gl.TEXTURE_WRAP_S, gl.CLAMP_TO_EDGE);
+    gl.texParameteri(gl.TEXTURE_2D, gl.TEXTURE_WRAP_T, gl.CLAMP_TO_EDGE);
+    gl.clearColor(0, 0, 0, 0);
+    this.initialized = true;
+  }
+  createShader(type, source) {
+    const gl = this.gl;
+    const shader = gl.createShader(type);
+    gl.shaderSource(shader, source);
+    gl.compileShader(shader);
+    if (!gl.getShaderParameter(shader, gl.COMPILE_STATUS)) {
+      const info = gl.getShaderInfoLog(shader);
+      gl.deleteShader(shader);
+      throw new Error("Shader compile failed: " + info);
+    }
+    return shader;
+  }
+  /** Check if renderer is ready */
+  isReady() {
+    return this.initialized;
+  }
+  /** Render CRT effect */
+  render(input, options = {}) {
+    if (!this.initialized || !this.gl || !this.canvas) {
+      throw new Error("Renderer not initialized");
+    }
+    const gl = this.gl;
+    const data = input instanceof ImageData ? input.data : input.data;
+    const width = input.width;
+    const height = input.height;
+    const scale = Math.min(32, Math.max(2, options.scale ?? 3));
+    const outWidth = width * scale;
+    const outHeight = height * scale;
+    if (this.currentCanvasSize.width !== outWidth || this.currentCanvasSize.height !== outHeight) {
+      this.canvas.width = outWidth;
+      this.canvas.height = outHeight;
+      this.currentCanvasSize = { width: outWidth, height: outHeight };
+      gl.viewport(0, 0, outWidth, outHeight);
+    }
+    gl.uniform2f(this.uniforms.uRes, outWidth, outHeight);
+    gl.uniform2f(this.uniforms.uWarp, options.warpX ?? 0.015, options.warpY ?? 0.02);
+    gl.uniform1f(this.uniforms.uScanHardness, options.scanHardness ?? -4);
+    gl.uniform1f(this.uniforms.uScanOpacity, options.scanOpacity ?? 0.5);
+    gl.uniform1f(this.uniforms.uMaskOpacity, options.maskOpacity ?? 0.3);
+    gl.uniform1i(this.uniforms.uEnableWarp, options.enableWarp !== false ? 1 : 0);
+    gl.uniform1i(this.uniforms.uEnableScanlines, options.enableScanlines !== false ? 1 : 0);
+    gl.uniform1i(this.uniforms.uEnableMask, options.enableMask !== false ? 1 : 0);
+    gl.bindTexture(gl.TEXTURE_2D, this.texture);
+    if (this.currentTexSize.width !== width || this.currentTexSize.height !== height) {
+      gl.texImage2D(gl.TEXTURE_2D, 0, gl.RGBA, width, height, 0, gl.RGBA, gl.UNSIGNED_BYTE, data);
+      this.currentTexSize = { width, height };
+    } else {
+      gl.texSubImage2D(gl.TEXTURE_2D, 0, 0, 0, width, height, gl.RGBA, gl.UNSIGNED_BYTE, data);
+    }
+    gl.clear(gl.COLOR_BUFFER_BIT);
+    gl.drawArrays(gl.TRIANGLES, 0, 3);
+    const pixels = new Uint8ClampedArray(outWidth * outHeight * 4);
+    gl.readPixels(0, 0, outWidth, outHeight, gl.RGBA, gl.UNSIGNED_BYTE, pixels);
+    return {
+      data: pixels,
+      width: outWidth,
+      height: outHeight
+    };
+  }
+  /** Dispose resources */
+  dispose() {
+    if (this.gl) {
+      if (this.texture) this.gl.deleteTexture(this.texture);
+      if (this.program) this.gl.deleteProgram(this.program);
+      this.gl = null;
+    }
+    this.canvas = null;
+    this.initialized = false;
+  }
+};
+var CRT_PRESETS = {
+  default: {},
+  authentic: {
+    warpX: 0.02,
+    warpY: 0.025,
+    scanHardness: -6,
+    scanOpacity: 0.6,
+    maskOpacity: 0.4
+  },
+  subtle: {
+    warpX: 8e-3,
+    warpY: 0.01,
+    scanHardness: -3,
+    scanOpacity: 0.3,
+    maskOpacity: 0.15
+  },
+  flat: {
+    warpX: 0,
+    warpY: 0,
+    enableWarp: false,
+    scanHardness: -4,
+    scanOpacity: 0.5,
+    maskOpacity: 0.3
+  }
+};
+
+// src/hex-gpu.ts
+var VERTEX_SHADER2 = `#version 300 es
+layout(location = 0) in vec2 position;
+out vec2 vUv;
+
+void main() {
+    vUv = position * 0.5 + 0.5;
+    gl_Position = vec4(position, 0.0, 1.0);
+}`;
+var FRAGMENT_SHADER2 = `#version 300 es
+precision highp float;
+
+uniform sampler2D uTex;
+uniform vec2 uOutputRes;
+uniform vec2 uInputRes;
+uniform float uScale;
+uniform int uOrientation; // 0 = flat-top, 1 = pointy-top
+uniform int uDrawBorders;
+uniform vec4 uBorderColor;
+uniform float uBorderThickness;
+uniform vec4 uBackgroundColor;
+
+in vec2 vUv;
+out vec4 outColor;
+
+const float SQRT3 = 1.732050808;
+const float INV_SQRT3 = 0.577350269;
+
+// Convert output pixel to hex coordinate (flat-top)
+vec2 pixelToHexFlat(vec2 pos, float scale) {
+    float hSpacing = scale * 1.5;
+    float vSpacing = scale * SQRT3;
+    
+    float col = pos.x / hSpacing;
+    int colInt = int(floor(col));
+    
+    // Check if odd column (offset)
+    bool isOffset = (colInt & 1) == 1;
+    float yOffset = isOffset ? vSpacing * 0.5 : 0.0;
+    
+    float row = (pos.y - yOffset) / vSpacing;
+    int rowInt = int(floor(row));
+    
+    // Refine with corner detection
+    float cellX = pos.x - float(colInt) * hSpacing;
+    float cellY = pos.y - float(rowInt) * vSpacing - yOffset;
+    
+    float quarterW = scale * 0.5;
+    float halfH = vSpacing * 0.5;
+    
+    if (cellX < quarterW) {
+        float distFromCenter = abs(cellY - halfH);
+        float edgeX = distFromCenter * INV_SQRT3;
+        
+        if (cellX < quarterW - edgeX) {
+            if (cellY < halfH) {
+                rowInt -= 1;
+            }
+            colInt -= 1;
+        }
+    }
+    
+    return vec2(float(colInt), float(rowInt));
+}
+
+// Convert output pixel to hex coordinate (pointy-top)
+vec2 pixelToHexPointy(vec2 pos, float scale) {
+    float hSpacing = scale * SQRT3;
+    float vSpacing = scale * 1.5;
+    
+    float row = pos.y / vSpacing;
+    int rowInt = int(floor(row));
+    
+    // Check if odd row (offset)
+    bool isOffset = (rowInt & 1) == 1;
+    float xOffset = isOffset ? hSpacing * 0.5 : 0.0;
+    
+    float col = (pos.x - xOffset) / hSpacing;
+    int colInt = int(floor(col));
+    
+    // Refine with corner detection
+    float cellX = pos.x - float(colInt) * hSpacing - xOffset;
+    float cellY = pos.y - float(rowInt) * vSpacing;
+    
+    float halfW = hSpacing * 0.5;
+    float quarterH = scale * 0.5;
+    
+    if (cellY < quarterH) {
+        float distFromCenter = abs(cellX - halfW);
+        float edgeY = distFromCenter * SQRT3;
+        
+        if (cellY < edgeY) {
+            if (cellX < halfW && isOffset) {
+                colInt -= 1;
+            }
+            rowInt -= 1;
+        }
+    }
+    
+    return vec2(float(colInt), float(rowInt));
+}
+
+// Check if pixel is on hex border
+bool isBorderPixel(vec2 pos, float scale, int orientation, float thickness) {
+    for (float dy = -thickness; dy <= thickness; dy += 1.0) {
+        for (float dx = -thickness; dx <= thickness; dx += 1.0) {
+            if (dx == 0.0 && dy == 0.0) continue;
+            
+            vec2 h1 = orientation == 0 
+                ? pixelToHexFlat(pos, scale) 
+                : pixelToHexPointy(pos, scale);
+            vec2 h2 = orientation == 0 
+                ? pixelToHexFlat(pos + vec2(dx, dy), scale) 
+                : pixelToHexPointy(pos + vec2(dx, dy), scale);
+            
+            if (h1 != h2) return true;
+        }
+    }
+    return false;
+}
+
+void main() {
+    vec2 pixelPos = vUv * uOutputRes;
+    
+    // Get hex coordinate
+    vec2 hexCoord = uOrientation == 0 
+        ? pixelToHexFlat(pixelPos, uScale) 
+        : pixelToHexPointy(pixelPos, uScale);
+    
+    // Check bounds
+    if (hexCoord.x < 0.0 || hexCoord.y < 0.0 || 
+        hexCoord.x >= uInputRes.x || hexCoord.y >= uInputRes.y) {
+        outColor = uBackgroundColor;
+        return;
+    }
+    
+    // Check for border
+    if (uDrawBorders == 1 && uBorderThickness > 0.0) {
+        if (isBorderPixel(pixelPos, uScale, uOrientation, uBorderThickness)) {
+            outColor = uBorderColor;
+            return;
+        }
+    }
+    
+    // Sample source pixel (add 0.5 for pixel center)
+    vec2 texCoord = (hexCoord + 0.5) / uInputRes;
+    outColor = texture(uTex, texCoord);
+}`;
+function parseColor(color, defaultColor) {
+  if (color === void 0) return defaultColor;
+  if (typeof color === "number") {
+    return [
+      (color >> 24 & 255) / 255,
+      (color >> 16 & 255) / 255,
+      (color >> 8 & 255) / 255,
+      (color & 255) / 255
+    ];
+  }
+  if (color === "transparent") return [0, 0, 0, 0];
+  if (color.startsWith("#")) {
+    const hex = color.slice(1);
+    if (hex.length === 6) {
+      return [
+        parseInt(hex.slice(0, 2), 16) / 255,
+        parseInt(hex.slice(2, 4), 16) / 255,
+        parseInt(hex.slice(4, 6), 16) / 255,
+        1
+      ];
+    }
+    if (hex.length === 8) {
+      return [
+        parseInt(hex.slice(0, 2), 16) / 255,
+        parseInt(hex.slice(2, 4), 16) / 255,
+        parseInt(hex.slice(4, 6), 16) / 255,
+        parseInt(hex.slice(6, 8), 16) / 255
+      ];
+    }
+  }
+  return defaultColor;
+}
+function hexGetDimensions(srcWidth, srcHeight, scale, orientation = "flat-top") {
+  const SQRT3 = 1.732050808;
+  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)
+    };
+  }
+}
+var HexGpuRenderer = class _HexGpuRenderer {
+  constructor() {
+    this.gl = null;
+    this.canvas = null;
+    this.program = null;
+    this.texture = null;
+    this.uniforms = {};
+    this.initialized = false;
+    this.currentCanvasSize = { width: 0, height: 0 };
+    this.currentTexSize = { width: 0, height: 0 };
+  }
+  /** Create a new HEX GPU renderer */
+  static create() {
+    const renderer = new _HexGpuRenderer();
+    renderer.init();
+    return renderer;
+  }
+  init() {
+    if (typeof OffscreenCanvas === "undefined") {
+      throw new Error("OffscreenCanvas not supported");
+    }
+    this.canvas = new OffscreenCanvas(1, 1);
+    this.gl = this.canvas.getContext("webgl2", {
+      alpha: true,
+      premultipliedAlpha: false,
+      desynchronized: true,
+      powerPreference: "high-performance",
+      antialias: false
+    });
+    if (!this.gl) {
+      throw new Error("WebGL2 not supported");
+    }
+    const gl = this.gl;
+    const vs = this.createShader(gl.VERTEX_SHADER, VERTEX_SHADER2);
+    const fs = this.createShader(gl.FRAGMENT_SHADER, FRAGMENT_SHADER2);
+    this.program = gl.createProgram();
+    gl.attachShader(this.program, vs);
+    gl.attachShader(this.program, fs);
+    gl.linkProgram(this.program);
+    if (!gl.getProgramParameter(this.program, gl.LINK_STATUS)) {
+      throw new Error("Shader program link failed: " + gl.getProgramInfoLog(this.program));
+    }
+    gl.useProgram(this.program);
+    this.uniforms = {
+      uTex: gl.getUniformLocation(this.program, "uTex"),
+      uOutputRes: gl.getUniformLocation(this.program, "uOutputRes"),
+      uInputRes: gl.getUniformLocation(this.program, "uInputRes"),
+      uScale: gl.getUniformLocation(this.program, "uScale"),
+      uOrientation: gl.getUniformLocation(this.program, "uOrientation"),
+      uDrawBorders: gl.getUniformLocation(this.program, "uDrawBorders"),
+      uBorderColor: gl.getUniformLocation(this.program, "uBorderColor"),
+      uBorderThickness: gl.getUniformLocation(this.program, "uBorderThickness"),
+      uBackgroundColor: gl.getUniformLocation(this.program, "uBackgroundColor")
+    };
+    gl.uniform1i(this.uniforms.uTex, 0);
+    const buf = gl.createBuffer();
+    gl.bindBuffer(gl.ARRAY_BUFFER, buf);
+    gl.bufferData(gl.ARRAY_BUFFER, new Float32Array([-1, -1, 3, -1, -1, 3]), gl.STATIC_DRAW);
+    gl.enableVertexAttribArray(0);
+    gl.vertexAttribPointer(0, 2, gl.FLOAT, false, 0, 0);
+    this.texture = gl.createTexture();
+    gl.bindTexture(gl.TEXTURE_2D, this.texture);
+    gl.texParameteri(gl.TEXTURE_2D, gl.TEXTURE_MIN_FILTER, gl.NEAREST);
+    gl.texParameteri(gl.TEXTURE_2D, gl.TEXTURE_MAG_FILTER, gl.NEAREST);
+    gl.texParameteri(gl.TEXTURE_2D, gl.TEXTURE_WRAP_S, gl.CLAMP_TO_EDGE);
+    gl.texParameteri(gl.TEXTURE_2D, gl.TEXTURE_WRAP_T, gl.CLAMP_TO_EDGE);
+    gl.clearColor(0, 0, 0, 0);
+    this.initialized = true;
+  }
+  createShader(type, source) {
+    const gl = this.gl;
+    const shader = gl.createShader(type);
+    gl.shaderSource(shader, source);
+    gl.compileShader(shader);
+    if (!gl.getShaderParameter(shader, gl.COMPILE_STATUS)) {
+      const info = gl.getShaderInfoLog(shader);
+      gl.deleteShader(shader);
+      throw new Error("Shader compile failed: " + info);
+    }
+    return shader;
+  }
+  /** Check if renderer is ready */
+  isReady() {
+    return this.initialized;
+  }
+  /** Render hexagonal effect */
+  render(input, options = {}) {
+    if (!this.initialized || !this.gl || !this.canvas) {
+      throw new Error("Renderer not initialized");
+    }
+    const gl = this.gl;
+    const data = input instanceof ImageData ? input.data : input.data;
+    const width = input.width;
+    const height = input.height;
+    const scale = Math.min(32, Math.max(2, options.scale ?? 16));
+    const orientation = options.orientation ?? "flat-top";
+    const { width: outWidth, height: outHeight } = hexGetDimensions(width, height, scale, orientation);
+    if (this.currentCanvasSize.width !== outWidth || this.currentCanvasSize.height !== outHeight) {
+      this.canvas.width = outWidth;
+      this.canvas.height = outHeight;
+      this.currentCanvasSize = { width: outWidth, height: outHeight };
+      gl.viewport(0, 0, outWidth, outHeight);
+    }
+    gl.uniform2f(this.uniforms.uOutputRes, outWidth, outHeight);
+    gl.uniform2f(this.uniforms.uInputRes, width, height);
+    gl.uniform1f(this.uniforms.uScale, scale);
+    gl.uniform1i(this.uniforms.uOrientation, orientation === "flat-top" ? 0 : 1);
+    gl.uniform1i(this.uniforms.uDrawBorders, options.drawBorders ? 1 : 0);
+    gl.uniform1f(this.uniforms.uBorderThickness, options.borderThickness ?? 1);
+    const borderColor = parseColor(options.borderColor, [0.16, 0.16, 0.16, 1]);
+    gl.uniform4f(this.uniforms.uBorderColor, ...borderColor);
+    const bgColor = parseColor(options.backgroundColor, [0, 0, 0, 0]);
+    gl.uniform4f(this.uniforms.uBackgroundColor, ...bgColor);
+    gl.bindTexture(gl.TEXTURE_2D, this.texture);
+    if (this.currentTexSize.width !== width || this.currentTexSize.height !== height) {
+      gl.texImage2D(gl.TEXTURE_2D, 0, gl.RGBA, width, height, 0, gl.RGBA, gl.UNSIGNED_BYTE, data);
+      this.currentTexSize = { width, height };
+    } else {
+      gl.texSubImage2D(gl.TEXTURE_2D, 0, 0, 0, width, height, gl.RGBA, gl.UNSIGNED_BYTE, data);
+    }
+    gl.clear(gl.COLOR_BUFFER_BIT);
+    gl.drawArrays(gl.TRIANGLES, 0, 3);
+    const pixels = new Uint8ClampedArray(outWidth * outHeight * 4);
+    gl.readPixels(0, 0, outWidth, outHeight, gl.RGBA, gl.UNSIGNED_BYTE, pixels);
+    return {
+      data: pixels,
+      width: outWidth,
+      height: outHeight
+    };
+  }
+  /** Dispose resources */
+  dispose() {
+    if (this.gl) {
+      if (this.texture) this.gl.deleteTexture(this.texture);
+      if (this.program) this.gl.deleteProgram(this.program);
+      this.gl = null;
+    }
+    this.canvas = null;
+    this.initialized = false;
+  }
+};
+var HEX_PRESETS = {
+  default: {},
+  bordered: {
+    drawBorders: true,
+    borderColor: "#282828",
+    borderThickness: 1
+  },
+  pointy: {
+    orientation: "pointy-top",
+    drawBorders: false
+  }
+};
+
+// 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 () => {
+    try {
+      const wasm2 = await Promise.resolve().then(() => (init_renderart_wasm(), renderart_wasm_exports));
+      await wasm2.default();
+      wasmModule = wasm2;
+      wasmMemory = wasmModule.get_memory();
+      return wasmModule;
+    } catch (e) {
+      throw new Error(`Failed to load WASM module: ${e}`);
+    }
+  })();
+  return loadPromise;
+}
+function isWasmLoaded() {
+  return wasmModule !== null;
+}
+function getOutputData(result) {
+  if (!wasmMemory) throw new Error("WASM memory not available");
+  const buffer = new Uint8Array(wasmMemory.buffer, result.ptr, result.len);
+  return new Uint8ClampedArray(buffer.slice());
+}
+function toUint8Array(input) {
+  const data = input instanceof ImageData ? input.data : input.data;
+  return data instanceof Uint8Array ? data : new Uint8Array(data);
+}
+function parseColorToU32(color, defaultVal) {
+  if (color === void 0) return defaultVal;
+  if (typeof color === "number") return color;
+  if (color === "transparent") return 0;
+  if (color.startsWith("#")) {
+    const hex = color.slice(1);
+    if (hex.length === 6) {
+      return parseInt(hex, 16) << 8 | 255;
+    }
+    if (hex.length === 8) {
+      return parseInt(hex, 16);
+    }
+  }
+  return defaultVal;
+}
+var CrtCpuRenderer = class _CrtCpuRenderer {
+  constructor() {
+    this.ready = false;
+  }
+  /** Create and initialize renderer */
+  static async create() {
+    const renderer = new _CrtCpuRenderer();
+    await renderer.init();
+    return renderer;
+  }
+  async init() {
+    await loadWasm();
+    this.ready = true;
+  }
+  /** Check if renderer is ready */
+  isReady() {
+    return this.ready;
+  }
+  /** Render CRT effect */
+  render(input, options = {}) {
+    if (!this.ready || !wasmModule) {
+      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);
+    return {
+      data: getOutputData(result),
+      width: result.width,
+      height: result.height
+    };
+  }
+  /** Dispose resources */
+  dispose() {
+    this.ready = false;
+  }
+};
+var HexCpuRenderer = class _HexCpuRenderer {
+  constructor() {
+    this.ready = false;
+  }
+  /** Create and initialize renderer */
+  static async create() {
+    const renderer = new _HexCpuRenderer();
+    await renderer.init();
+    return renderer;
+  }
+  async init() {
+    await loadWasm();
+    this.ready = true;
+  }
+  /** Check if renderer is ready */
+  isReady() {
+    return this.ready;
+  }
+  /** Render hexagonal effect */
+  render(input, options = {}) {
+    if (!this.ready || !wasmModule) {
+      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);
+    return {
+      data: getOutputData(result),
+      width: result.width,
+      height: result.height
+    };
+  }
+  /** Get output dimensions */
+  getDimensions(srcWidth, srcHeight, scale, orientation = "flat-top") {
+    if (!this.ready || !wasmModule) {
+      throw new Error("Renderer not initialized");
+    }
+    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;
+  }
+};
+var XbrzCpuRenderer = class _XbrzCpuRenderer {
+  constructor() {
+    this.ready = false;
+  }
+  /** Create and initialize renderer */
+  static async create() {
+    const renderer = new _XbrzCpuRenderer();
+    await renderer.init();
+    return renderer;
+  }
+  async init() {
+    await loadWasm();
+    this.ready = true;
+  }
+  /** Check if renderer is ready */
+  isReady() {
+    return this.ready;
+  }
+  /** Render xBRZ scaling */
+  render(input, options = {}) {
+    if (!this.ready || !wasmModule) {
+      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);
+    return {
+      data: getOutputData(result),
+      width: result.width,
+      height: result.height
+    };
+  }
+  /** Dispose resources */
+  dispose() {
+    this.ready = false;
+  }
+};
+var XBRZ_PRESETS = {
+  default: {},
+  sharp: {
+    luminanceWeight: 1,
+    equalColorTolerance: 20,
+    dominantDirectionThreshold: 4.4,
+    steepDirectionThreshold: 2.2
+  },
+  smooth: {
+    luminanceWeight: 0.8,
+    equalColorTolerance: 35,
+    dominantDirectionThreshold: 5,
+    steepDirectionThreshold: 2.5
+  }
+};
+
+// src/renderart.ts
+function checkWebGL2() {
+  if (typeof OffscreenCanvas === "undefined") return false;
+  try {
+    const canvas = new OffscreenCanvas(1, 1);
+    return !!canvas.getContext("webgl2");
+  } catch {
+    return false;
+  }
+}
+function getMaxTextureSize() {
+  if (!checkWebGL2()) return 0;
+  try {
+    const canvas = new OffscreenCanvas(1, 1);
+    const gl = canvas.getContext("webgl2");
+    return gl?.getParameter(gl.MAX_TEXTURE_SIZE) ?? 0;
+  } catch {
+    return 0;
+  }
+}
+var CrtEngine = class {
+  constructor(gpuAvailable, cpuAvailable) {
+    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();
+    }
+    if (!this.gpuRenderer) throw new Error("GPU renderer not available");
+    return this.gpuRenderer;
+  }
+  /** Initialize CPU renderer */
+  async ensureCpu() {
+    if (!this.cpuRenderer && this.cpuAvailable) {
+      this.cpuRenderer = await CrtCpuRenderer.create();
+    }
+    if (!this.cpuRenderer) throw new Error("CPU renderer not available");
+    return this.cpuRenderer;
+  }
+  async render(input, optionsOrPreset, overrides) {
+    let options = {};
+    if (typeof optionsOrPreset === "string") {
+      options = { ...CRT_PRESETS[optionsOrPreset], ...overrides };
+    } else if (optionsOrPreset) {
+      options = optionsOrPreset;
+    }
+    const backend = options.backend ?? "auto";
+    if (backend === "gpu" || backend === "auto" && this.gpuAvailable) {
+      try {
+        return this.ensureGpu().render(input, options);
+      } catch (e) {
+        if (backend === "gpu") throw e;
+      }
+    }
+    const cpu = await this.ensureCpu();
+    return cpu.render(input, options);
+  }
+  /** Render synchronously (GPU only) */
+  renderSync(input, options) {
+    return this.ensureGpu().render(input, options ?? {});
+  }
+  /** Dispose resources */
+  dispose() {
+    this.gpuRenderer?.dispose();
+    this.cpuRenderer?.dispose();
+    this.gpuRenderer = null;
+    this.cpuRenderer = null;
+  }
+};
+var HexEngine = class {
+  constructor(gpuAvailable, cpuAvailable) {
+    this.gpuRenderer = null;
+    this.cpuRenderer = null;
+    this.gpuAvailable = gpuAvailable;
+    this.cpuAvailable = cpuAvailable;
+  }
+  ensureGpu() {
+    if (!this.gpuRenderer && this.gpuAvailable) {
+      this.gpuRenderer = HexGpuRenderer.create();
+    }
+    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();
+    }
+    if (!this.cpuRenderer) throw new Error("CPU renderer not available");
+    return this.cpuRenderer;
+  }
+  async render(input, optionsOrPreset, overrides) {
+    let options = {};
+    if (typeof optionsOrPreset === "string") {
+      options = { ...HEX_PRESETS[optionsOrPreset], ...overrides };
+    } else if (optionsOrPreset) {
+      options = optionsOrPreset;
+    }
+    const backend = options.backend ?? "auto";
+    if (backend === "gpu" || backend === "auto" && this.gpuAvailable) {
+      try {
+        return this.ensureGpu().render(input, options);
+      } catch (e) {
+        if (backend === "gpu") throw e;
+      }
+    }
+    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";
+    return hexGetDimensions(srcWidth, srcHeight, scale, orientation);
+  }
+  dispose() {
+    this.gpuRenderer?.dispose();
+    this.cpuRenderer?.dispose();
+    this.gpuRenderer = null;
+    this.cpuRenderer = null;
+  }
+};
+var XbrzEngine = class {
+  constructor(cpuAvailable) {
+    this.cpuRenderer = null;
+    this.cpuAvailable = cpuAvailable;
+  }
+  async ensureCpu() {
+    if (!this.cpuRenderer && this.cpuAvailable) {
+      this.cpuRenderer = await XbrzCpuRenderer.create();
+    }
+    if (!this.cpuRenderer) throw new Error("CPU renderer not available");
+    return this.cpuRenderer;
+  }
+  async 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);
+  }
+  /** Get output dimensions */
+  getDimensions(srcWidth, srcHeight, scale = 2) {
+    const s = Math.min(6, Math.max(2, scale));
+    return { width: srcWidth * s, height: srcHeight * s };
+  }
+  dispose() {
+    this.cpuRenderer?.dispose();
+    this.cpuRenderer = null;
+  }
+};
+var RenderArt = class _RenderArt {
+  constructor(gpuAvailable, cpuAvailable) {
+    this.crt = new CrtEngine(gpuAvailable, cpuAvailable);
+    this.hex = new HexEngine(gpuAvailable, cpuAvailable);
+    this.xbrz = new XbrzEngine(cpuAvailable);
+    const maxTextureSize = gpuAvailable ? getMaxTextureSize() : 0;
+    this._capabilities = {
+      gpu: gpuAvailable,
+      cpu: cpuAvailable,
+      maxTextureSize,
+      recommendedBackend: gpuAvailable ? "gpu" : cpuAvailable ? "cpu" : "auto"
+    };
+  }
+  /** Create and initialize RenderArt instance */
+  static async 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, cpuAvailable);
+  }
+  /** Get renderer capabilities */
+  get capabilities() {
+    return { ...this._capabilities };
+  }
+  /** Dispose all resources */
+  dispose() {
+    this.crt.dispose();
+    this.hex.dispose();
+    this.xbrz.dispose();
+  }
+};
+
+export { CRT_PRESETS, CrtCpuRenderer, CrtGpuRenderer, HEX_PRESETS, HexCpuRenderer, HexGpuRenderer, RenderArt, XBRZ_PRESETS, XbrzCpuRenderer, hexGetDimensions, isWasmLoaded, loadWasm };
+//# sourceMappingURL=index.mjs.map
+//# sourceMappingURL=index.mjs.map