@ludicon/spark.js 0.0.14 → 0.1.0

package/dist/spark.esm.js

@@ -1,6 +1,53 @@
-const V = /* @__PURE__ */ Object.assign({ "./spark_astc_rgb.wgsl": () => import("./spark_astc_rgb-DaSIMKXW.js"), "./spark_astc_rgba.wgsl": () => import("./spark_astc_rgba-BToA2Rcq.js"), "./spark_bc1_rgb.wgsl": () => import("./spark_bc1_rgb-DZwuM1tO.js"), "./spark_bc4_r.wgsl": () => import("./spark_bc4_r-DjThizCH.js"), "./spark_bc5_rg.wgsl": () => import("./spark_bc5_rg-6bO0Gvo9.js"), "./spark_bc7_rgb.wgsl": () => import("./spark_bc7_rgb-FXpBw9fE.js"), "./spark_bc7_rgba.wgsl": () => import("./spark_bc7_rgba-C8Hi2pUY.js"), "./spark_eac_r.wgsl": () => import("./spark_eac_r-D8HGiglc.js"), "./spark_eac_rg.wgsl": () => import("./spark_eac_rg-DvsrLP9h.js"), "./spark_etc2_rgb.wgsl": () => import("./spark_etc2_rgb-C-j5FZpn.js"), "./utils.wgsl": () => import("./utils-BigAnOxg.js") }), I = Object.fromEntries(
-  Object.entries(V).map(([c, e]) => [c.replace("./", ""), async () => (await e()).default])
-), i = {
+const ge = /* @__PURE__ */ Object.assign({ "./spark_astc_rgb.wgsl": () => import("./spark_astc_rgb-DaSIMKXW.js"), "./spark_astc_rgba.wgsl": () => import("./spark_astc_rgba-BToA2Rcq.js"), "./spark_bc1_rgb.wgsl": () => import("./spark_bc1_rgb-DZwuM1tO.js"), "./spark_bc4_r.wgsl": () => import("./spark_bc4_r-DjThizCH.js"), "./spark_bc5_rg.wgsl": () => import("./spark_bc5_rg-6bO0Gvo9.js"), "./spark_bc7_rgb.wgsl": () => import("./spark_bc7_rgb-FXpBw9fE.js"), "./spark_bc7_rgba.wgsl": () => import("./spark_bc7_rgba-C8Hi2pUY.js"), "./spark_eac_r.wgsl": () => import("./spark_eac_r-D8HGiglc.js"), "./spark_eac_rg.wgsl": () => import("./spark_eac_rg-DvsrLP9h.js"), "./spark_etc2_rgb.wgsl": () => import("./spark_etc2_rgb-C-j5FZpn.js"), "./utils.wgsl": () => import("./utils-D_dYVlAC.js") }), Z = Object.fromEntries(
+  Object.entries(ge).map(([i, t]) => [i.replace("./", ""), async () => (await t()).default])
+);
+function O(i, t) {
+  if (!i)
+    throw new Error(t);
+}
+function he() {
+  const i = navigator.userAgent;
+  if (i.includes("Chrome") || i.includes("Chromium"))
+    return null;
+  const t = i.match(/Safari\/(\d+(\.\d+)?)/);
+  return t && parseFloat(t[1]);
+}
+function J() {
+  const i = navigator.userAgent.match(/Firefox\/(\d+(\.\d+)?)/);
+  return i && parseFloat(i[1]);
+}
+function pe(i) {
+  return /\.svg(?:$|\?)/i.test(i) || /^data:image\/svg\+xml[,;]/i.test(i);
+}
+function ee(i) {
+  return new Promise((t, r) => {
+    const e = new Image();
+    e.crossOrigin = "anonymous", e.decoding = "async", e.onload = () => t(e), e.onerror = r, e.src = i;
+  });
+}
+async function _e(i, t = {}) {
+  const r = await fetch(i, { mode: "cors" });
+  if (!r.ok) throw new Error(`HTTP ${r.status} for ${i}`);
+  const e = await r.blob();
+  return createImageBitmap(e, {
+    imageOrientation: t.flipY ? "flipY" : "none",
+    colorSpaceConversion: t.colorSpaceConversion ?? "none",
+    premultiplyAlpha: "none"
+  });
+}
+const j = he(), Te = 619.1, Ee = j && j < Te;
+async function be(i) {
+  const t = document.createElement("canvas");
+  return t.width = i.naturalWidth || i.width, t.height = i.naturalHeight || i.height, t.getContext("2d").drawImage(i, 0, 0), createImageBitmap(t);
+}
+async function K(i, t = {}) {
+  const r = pe(i);
+  if (r && Ee) {
+    const e = await ee(i);
+    return be(e);
+  } else return r || j ? ee(i) : _e(i, t);
+}
+const a = {
   ASTC_4x4_RGB: 0,
   ASTC_4x4_RGBA: 1,
   // ASTC_4x4_RGBM: 2,
@@ -19,7 +66,7 @@ const V = /* @__PURE__ */ Object.assign({ "./spark_astc_rgb.wgsl": () => import(
   // BC6H_RGB: 15,
   BC7_RGB: 16,
   BC7_RGBA: 17
-}, G = [
+}, N = [
   /* 0  */
   "astc-4x4-rgb",
   // ASTC_4x4_RGB
@@ -66,7 +113,7 @@ const V = /* @__PURE__ */ Object.assign({ "./spark_astc_rgb.wgsl": () => import(
   /* 17 */
   "bc7-rgba"
   // BC7_RGBA
-], q = [
+], Re = [
   /* 0  */
   "spark_astc_rgb.wgsl",
   // ASTC_4x4_RGB
@@ -113,7 +160,7 @@ const V = /* @__PURE__ */ Object.assign({ "./spark_astc_rgb.wgsl": () => import(
   /* 17 */
   "spark_bc7_rgba.wgsl"
   // BC7_RGBA
-], W = [
+], Be = [
   /* 0  */
   16,
   // ASTC_4x4_RGB
@@ -160,81 +207,39 @@ const V = /* @__PURE__ */ Object.assign({ "./spark_astc_rgb.wgsl": () => import(
   /* 17 */
   16
   // BC7_RGB
-], Y = [
-  /* 0  */
-  4,
-  // ASTC_4x4_RGB
-  /* 1  */
-  4,
-  // ASTC_4x4_RGBA
-  /* 2  */
-  0,
-  /* 3  */
-  0,
-  /* 4  */
-  2,
-  // EAC_R
-  /* 5  */
-  2,
-  // EAC_RG
-  /* 6  */
-  8,
-  // ETC2_RGB
-  /* 7  */
-  0,
-  /* 8  */
-  0,
-  /* 9  */
-  8,
-  // BC1_RGB
-  /* 10 */
-  0,
-  /* 11 */
-  0,
-  /* 12 */
-  0,
-  /* 13 */
-  2,
-  // BC4_R
-  /* 14 */
-  2,
-  // BC5_RG
-  /* 15 */
-  0,
-  /* 16 */
-  4,
-  // BC7_RGB
-  /* 17 */
-  4
-  // BC7_RGB
-], P = Object.freeze({
-  "astc-4x4-rgb": i.ASTC_4x4_RGB,
-  "astc-4x4-rgba": i.ASTC_4x4_RGBA,
-  "eac-r": i.EAC_R,
-  "eac-rg": i.EAC_RG,
-  "etc2-rgb": i.ETC2_RGB,
-  "bc1-rgb": i.BC1_RGB,
-  "bc4-r": i.BC4_R,
-  "bc5-rg": i.BC5_RG,
-  "bc7-rgb": i.BC7_RGB,
-  "bc7-rgba": i.BC7_RGBA,
+], A = {
+  Linear: 0,
+  sRGB: 1,
+  Alpha: 2,
+  Normal: 4
+}, z = Object.freeze({
+  "astc-4x4-rgb": a.ASTC_4x4_RGB,
+  "astc-4x4-rgba": a.ASTC_4x4_RGBA,
+  "eac-r": a.EAC_R,
+  "eac-rg": a.EAC_RG,
+  "etc2-rgb": a.ETC2_RGB,
+  "bc1-rgb": a.BC1_RGB,
+  "bc4-r": a.BC4_R,
+  "bc5-rg": a.BC5_RG,
+  "bc7-rgb": a.BC7_RGB,
+  "bc7-rgba": a.BC7_RGBA,
   // aliases:
-  "astc-rgb": i.ASTC_4x4_RGB,
-  "astc-rgba": i.ASTC_4x4_RGBA,
+  "astc-rgb": a.ASTC_4x4_RGB,
+  "astc-rgba": a.ASTC_4x4_RGBA,
   // webgpu aliases:
-  "bc1-rgba-unorm": i.BC1_RGB,
-  "bc1-rgba-unorm-srgb": i.BC1_RGB,
-  "bc4-r-unorm": i.BC4_R,
-  "bc5-rg-unorm": i.BC5_RG,
-  "bc7-rgba-unorm": i.BC7_RGBA,
-  "bc7-rgba-unorm-srgb": i.BC7_RGBA,
-  "etc2-rgb8unorm": i.ETC2_RGB,
-  "etc2-rgb8unorm-srgb": i.ETC2_RGB,
-  "eac-r11unorm": i.EAC_R,
-  "eac-rg11unorm": i.EAC_RG,
-  "astc-4x4-unorm": i.ASTC_4x4_RGBA,
-  "astc-4x4-unorm-srgb": i.ASTC_4x4_RGBA
-}), $ = [
+  "bc1-rgba-unorm": a.BC1_RGB,
+  "bc1-rgba-unorm-srgb": a.BC1_RGB,
+  "bc4-r-unorm": a.BC4_R,
+  "bc5-rg-unorm": a.BC5_RG,
+  "bc7-rgba-unorm": a.BC7_RGBA,
+  "bc7-rgba-unorm-srgb": a.BC7_RGBA,
+  "etc2-rgb8unorm": a.ETC2_RGB,
+  "etc2-rgb8unorm-srgb": a.ETC2_RGB,
+  "eac-r11unorm": a.EAC_R,
+  "eac-rg11unorm": a.EAC_RG,
+  "astc-4x4-unorm": a.ASTC_4x4_RGBA,
+  "astc-4x4-unorm-srgb": a.ASTC_4x4_RGBA
+}), xe = [
   /* 0  */
   "astc-4x4-unorm",
   // ASTC_4x4_RGB
@@ -281,7 +286,7 @@ const V = /* @__PURE__ */ Object.assign({ "./spark_astc_rgb.wgsl": () => import(
   /* 17 */
   "bc7-rgba-unorm"
   // BC7_RGB
-], X = [
+], Ge = [
   /* 0  */
   !0,
   // ASTC_4x4_RGB
@@ -329,110 +334,113 @@ const V = /* @__PURE__ */ Object.assign({ "./spark_astc_rgb.wgsl": () => import(
   !0
   // BC7_RGB
 ];
-function w(c, e) {
-  if (!c)
-    throw new Error(e);
+function Ce(i) {
+  return Ge[i];
 }
-function H(c) {
-  return typeof GPUDevice < "u" && c instanceof GPUDevice;
+function Se(i) {
+  return i == a.ASTC_4x4_RGBA || i == a.BC7_RGBA;
 }
-function j() {
+function Pe(i) {
+  return typeof GPUDevice < "u" && i instanceof GPUDevice;
+}
+function Ae() {
   return ["iPad Simulator", "iPhone Simulator", "iPod Simulator", "iPad", "iPhone", "iPod"].includes(navigator.platform) || // iPad on iOS 13 detection
   navigator.userAgent.includes("Mac") && "ontouchend" in document;
 }
-function O() {
-  const c = navigator.userAgent.match(/Safari\/(\d+(\.\d+)?)/);
-  return c && parseFloat(c[1]);
-}
-function k() {
-  const c = navigator.userAgent.match(/Firefox\/(\d+(\.\d+)?)/);
-  return c && parseFloat(c[1]);
-}
-function Q(c) {
-  const e = /* @__PURE__ */ new Set(), r = {
-    "texture-compression-bc": [
-      i.BC1_RGB,
-      i.BC4_R,
-      i.BC5_RG,
-      i.BC7_RGB,
-      i.BC7_RGBA
-    ],
-    "texture-compression-etc2": [i.ETC2_RGB, i.EAC_R, i.EAC_RG],
-    "texture-compression-astc": [i.ASTC_4x4_RGB, i.ASTC_4x4_RGBA]
+function Ue(i) {
+  const t = /* @__PURE__ */ new Set(), r = {
+    "texture-compression-bc": [a.BC1_RG, a.BC4_R, a.BC5_RG, a.BC7_RGB, a.BC7_RGBA],
+    "texture-compression-etc2": [a.ETC2_RGB, a.EAC_R, a.EAC_RG],
+    "texture-compression-astc": [a.ASTC_4x4_RGB, a.ASTC_4x4_RGBA]
   };
-  for (const [t, s] of Object.entries(r))
-    if (c.features.has(t))
-      for (const n of s)
-        e.add(n);
-  return e;
+  for (const [e, s] of Object.entries(r))
+    if (i.features.has(e))
+      for (const o of s)
+        t.add(o);
+  return t;
 }
-function Z(c) {
-  const e = document.createElement("canvas");
-  e.width = c.width, e.height = c.height;
-  const r = e.getContext("2d");
-  r.drawImage(c, 0, 0);
-  const t = r.getImageData(0, 0, c.width, c.height);
-  return new Uint8Array(t.data.buffer);
+function we(i) {
+  const t = document.createElement("canvas");
+  t.width = i.width, t.height = i.height;
+  const r = t.getContext("2d");
+  r.drawImage(i, 0, 0);
+  const e = r.getImageData(0, 0, i.width, i.height);
+  return new Uint8Array(e.data.buffer);
 }
-function J(c) {
-  return /\.svg(?:$|\?)/i.test(c) || /^data:image\/svg\+xml[,;]/i.test(c);
-}
-function K(c) {
-  return new Promise((e, r) => {
-    const t = new Image();
-    t.crossOrigin = "anonymous", t.decoding = "async", t.onload = () => e(t), t.onerror = r, t.src = c;
-  });
-}
-async function ee(c, e = {}) {
-  const r = await fetch(c, { mode: "cors" });
-  if (!r.ok) throw new Error(`HTTP ${r.status} for ${c}`);
-  const t = await r.blob();
-  return createImageBitmap(t, {
-    imageOrientation: e.flipY ? "flipY" : "none",
-    colorSpaceConversion: e.colorSpaceConversion ?? "none",
-    premultiplyAlpha: "none"
-  });
-}
-const te = O();
-function N(c) {
-  return J(c) || te ? K(c) : ee(c);
-}
-const L = 256, F = 4;
-function re(c, e, r, t) {
-  let s = 0, n = 0;
-  const a = [];
+const te = 256, re = 4;
+function ye(i, t, r, e) {
+  let s = 0, o = 0;
+  const c = [];
   do {
-    const o = Math.ceil(c / 4), u = Math.ceil(e / 4), l = Math.ceil(o * r / L) * L, f = u * l;
-    s++, a.push({ offset: n, alignedSize: f, w: c, h: e, bw: o, bh: u, bytesPerRow: l }), n += f, c = Math.max(1, Math.floor(c / 2)), e = Math.max(1, Math.floor(e / 2));
-  } while (t && (c >= F || e >= F));
-  return { mipmapCount: s, outputSize: n, bufferRanges: a };
+    const n = Math.ceil(i / 4), f = Math.ceil(t / 4), u = Math.ceil(n * r / te) * te, l = f * u;
+    s++, c.push({ offset: o, alignedSize: l, w: i, h: t, bw: n, bh: f, bytesPerRow: u }), o += l, i = Math.max(1, Math.floor(i / 2)), t = Math.max(1, Math.floor(t / 2));
+  } while (e && (i >= re || t >= re));
+  return { mipmapCount: s, outputSize: o, bufferRanges: c };
 }
-class D {
+class me {
   #e;
-  #f;
-  #l = [];
+  #l;
+  #T;
+  #h = !1;
+  #f = [];
   #g;
-  #a = !1;
+  #d;
+  #p;
+  #a;
+  #E;
   #s;
-  #o;
-  #u;
-  #m;
   #i;
-  #n = new Array(3);
-  #r;
-  #p;
-  #c;
-  #G = 0;
+  #n;
+  #_;
+  #u;
+  #t = !1;
+  #o = null;
+  #c = null;
+  #m = null;
+  #B = 0;
+  #b = !1;
   /**
    * Initialize the encoder by detecting available compression formats.
    * @param {GPUDevice} device - WebGPU device.
    * @param {Object} options - Encoder options.
    * @param {boolean} options.preload - Whether to preload all encoder pipelines (false by default).
+   * @param {boolean} options.cacheTempResources - Whether to cache temporary resources for reuse across encodeTexture calls (false by default).
+   * @param {boolean} options.verbose - Whether to enable verbose logging (false by default).
    * @returns {Promise<void>} Resolves when initialization is complete.
    */
-  static async create(e, r = {}) {
-    const t = new D();
-    return await t.#B(e, r.preload ?? !1, r.useTimestampQueries ?? !1), t;
+  static async create(t, r = {}) {
+    const e = new me();
+    return await e.#w(
+      t,
+      r.preload ?? !1,
+      r.useTimestampQueries ?? !1,
+      r.verbose ?? !1,
+      r.cacheTempResources ?? !1
+    ), e;
+  }
+  dispose() {
+    for (const t of this.#f)
+      t.destroy();
+    this.#g.destroy(), this.#p.destroy(), this.#a.destroy(), this.#E.destroy(), this.#s.destroy();
+    for (let t = 0; t < 3; t++)
+      this.#i[t].destroy();
+    this.#n.destroy(), this.#_.destroy(), this.#u.destroy(), this.freeTempResources();
+  }
+  #x(...t) {
+    this.#b && console.log(...t);
+  }
+  #G(t) {
+    this.#b && console.time(t);
+  }
+  #C(t) {
+    this.#b && console.timeEnd(t);
+  }
+  /**
+   * Free cached temporary resources used by encodeTexture.
+   * Call this when you're done encoding textures to free up GPU memory.
+   */
+  freeTempResources() {
+    this.#o && (this.#o.destroy(), this.#o = null), this.#c && (this.#c.destroy(), this.#c = null), this.#m && (this.#m.destroy(), this.#m = null);
   }
   /**
    * Returns a list of supported texture compression format names.
@@ -441,34 +449,25 @@ class D {
    * (ASTC, ETC2, EAC, BCn) and filters it based on the formats actually supported
    * by the current device as determined by `Spark.supportedFormats`.
    *
-   * @returns {string[]} An array of format names (e.g., "bc1-rgb", "astc-4x4-rgba") that are supported on the current platform.
+   * @returns {string[]} An array of format names (e.g., "bc1-rgb", "astc-4x4-rgba") that are supported on the current device.
    *
    * @example
    * const spark = await Spark.create(device);
-   * const formats = spark.enumerateSupportedFormats();
+   * const formats = spark.getSupportedFormats();
    * console.log("Supported formats:", formats);
    */
-  enumerateSupportedFormats() {
-    const e = [
-      "astc-4x4-rgb",
-      "astc-4x4-rgba",
-      "eac-r",
-      "eac-rg",
-      "etc2-rgb",
-      "bc1-rgb",
-      "bc4-r",
-      "bc5-rg",
-      "bc7-rgb",
-      "bc7-rgba"
-    ], r = [];
-    for (const t of e) {
-      const s = P[t];
-      if (this.#t(s)) {
-        const n = Y[s];
-        r.push({ format: t, ratio: n });
-      }
-    }
-    return r;
+  getSupportedFormats() {
+    return Array.from(this.#l).map((t) => N[t]).filter(Boolean);
+  }
+  /**
+   * Returns whether the given format is supported on the current device.
+   *
+   * @param {string} format
+   * @returns {boolean} `true` if the format is supported, `false` otherwise.
+   */
+  isFormatSupported(t) {
+    const r = typeof t == "string" ? z[t] : t;
+    return this.#l.has(r);
   }
   /**
    * Determines the set of WebGPU features to request when initializing the device.
@@ -488,9 +487,9 @@ class D {
    * // Create spark object for the given device.
    * const spark = Spark.create(device)
    */
-  static getRequiredFeatures(e) {
+  static getRequiredFeatures(t) {
     const r = [];
-    return !j() && e.features.has("texture-compression-bc") && r.push("texture-compression-bc"), e.features.has("texture-compression-etc2") && r.push("texture-compression-etc2"), e.features.has("texture-compression-astc") && r.push("texture-compression-astc"), e.features.has("shader-f16") && r.push("shader-f16"), e.features.has("timestamp-query") && r.push("timestamp-query"), r;
+    return !Ae() && t.features.has("texture-compression-bc") && r.push("texture-compression-bc"), t.features.has("texture-compression-etc2") && r.push("texture-compression-etc2"), t.features.has("texture-compression-astc") && r.push("texture-compression-astc"), t.features.has("shader-f16") && r.push("shader-f16"), t.features.has("timestamp-query") && r.push("timestamp-query"), r;
   }
   /**
    * Try to determine the best compression options automatically. Do not use this in production, this is
@@ -500,12 +499,12 @@ class D {
    * @param {Object} options - Encoding options.
    * @returns {Object} - Recommended encoding options with an explicit encoding format.
    */
-  async selectPreferredOptions(e, r = {}) {
+  async selectPreferredOptions(t, r = {}) {
     if (r.format == null || r.format == "auto") {
-      const t = e instanceof Image || e instanceof ImageBitmap || e instanceof GPUTexture ? e : await N(e);
+      const e = t instanceof Image || t instanceof ImageBitmap || t instanceof GPUTexture ? t : await K(t);
       r.format = "auto";
-      const s = await this.#d(r, t);
-      r.format = G[s], t instanceof GPUTexture && t.format.endsWith("-srgb") && (r.srgb = !0), (s == i.EAC_RG || s == i.BC5_RG) && (r.normal = !0);
+      const s = await this.#A(r, e);
+      r.format = N[s], e instanceof GPUTexture && e.format.endsWith("-srgb") && (r.srgb = !0), (s == a.EAC_RG || s == a.BC5_RG) && (r.normal = !0);
     }
     return r;
   }
@@ -527,13 +526,18 @@ class D {
    *          - "auto" to analyze the input texture and detect the required channels.
    *            This has some overhead, so specifying a format explicitly is preferred.
    *
-   * @param {boolean} [options.alpha]
-   *        Hint for the automatic format selector. When no explicit format is provided,
-   *        the format is assumed to be "rgb". Supplying `alpha: true` will favor RGBA formats.
-   *
    * @param {boolean} [options.mips=false] | [options.generateMipmaps=false]
-   *        Whether to generate mipmaps. Mipmaps are generated with a basic box filter
-   *        in linear space.
+   *        Whether to generate mipmaps.
+   *
+   * @param {string} [options.mipmapFilter="magic"]
+   *        The filter to use for mipmap generation. Can be "box" for a simple box filter,
+   *        or "magic" for a higher-quality 4-tap filter with sharpening properties.
+   *
+   * @param {number[]} [options.mipsAlphaScale]
+   *        Optional array of alpha scale values to apply to each generated mipmap level.
+   *        The array should contain one value per mipmap level (starting with mip level 1,
+   *        since level 0 is the base image). Each value multiplies the alpha channel of
+   *        the corresponding mipmap level.
    *
    * @param {boolean} [options.srgb=false]
    *        Whether to encode the image in an sRGB format. Also affects mipmap generation.
@@ -548,97 +552,111 @@ class D {
    *
    * @returns {Promise<GPUTexture>} A promise resolving to the encoded GPU texture.
    */
-  async encodeTexture(e, r = {}) {
-    w(this.#e, "Spark is not initialized");
-    const t = e instanceof Image || e instanceof ImageBitmap || e instanceof GPUTexture ? e : await N(e);
-    console.log("Loaded image", t);
-    const s = await this.#d(r, t), n = this.#h(s), a = Math.ceil(t.width / 4) * 4, o = Math.ceil(t.height / 4) * 4, u = W[s], l = r.generateMipmaps || r.mips, { mipmapCount: f, outputSize: h, bufferRanges: m } = re(a, o, u, l), b = (r.srgb || r.format?.endsWith("srgb")) && X[s], _ = b ? 1 : r.normal ? 2 : 0, B = $[s] + (b ? "-srgb" : ""), A = b ? ["rgba8unorm", "rgba8unorm-srgb"] : ["rgba8unorm"], x = this.#G++;
-    console.time("create input texture #" + x);
-    let C = GPUTextureUsage.TEXTURE_BINDING | GPUTextureUsage.COPY_DST;
-    this.#a ? C |= GPUTextureUsage.RENDER_ATTACHMENT : C |= GPUTextureUsage.STORAGE_BINDING;
-    const y = r.flipY || a != t.width || o != t.height;
-    !y && !(t instanceof GPUTexture) && (C |= GPUTextureUsage.RENDER_ATTACHMENT);
-    const p = this.#e.createCommandEncoder();
-    p.pushDebugGroup?.("spark process texture"), this.#r && typeof p.writeTimestamp == "function" && p.writeTimestamp(this.#r, 0);
-    let d;
-    (y || !(t instanceof GPUTexture && !l)) && (d = this.#e.createTexture({
-      size: [a, o, 1],
-      mipLevelCount: f,
-      format: "rgba8unorm",
-      usage: C,
-      viewFormats: A
-    }));
-    let R;
-    y ? t instanceof GPUTexture ? this.#_(p, t, d, a, o, b, r.flipY) : (R = this.#e.createTexture({
-      size: [t.width, t.height, 1],
-      mipLevelCount: 1,
-      format: "rgba8unorm",
-      // RENDER_ATTACHMENT usage is necessary for copyExternalImageToTexture
-      usage: GPUTextureUsage.TEXTURE_BINDING | GPUTextureUsage.COPY_DST | GPUTextureUsage.RENDER_ATTACHMENT,
-      viewFormats: A
-    }), this.#e.queue.copyExternalImageToTexture(
-      { source: t },
-      { texture: R },
-      { width: t.width, height: t.height }
-    ), this.#_(p, R, d, a, o, _, r.flipY)) : t instanceof GPUTexture ? l ? p.copyTextureToTexture({ texture: t }, { texture: d }, { width: a, height: o }) : d = t : this.#e.queue.copyExternalImageToTexture({ source: t }, { texture: d }, { width: a, height: o }), l && this.#w(p, d, f, a, o, _), p.popDebugGroup?.(), console.timeEnd("create input texture #" + x);
-    const E = this.#e.createTexture({
-      size: [a, o, 1],
-      mipLevelCount: f,
-      format: B,
+  async encodeTexture(t, r = {}) {
+    O(this.#e, "Spark is not initialized");
+    const e = t instanceof Image || t instanceof ImageBitmap || t instanceof GPUTexture ? t : await K(t);
+    this.#x("Loaded image", e);
+    const s = await this.#A(r, e), o = this.#S(s), c = Math.ceil(e.width / 4) * 4, n = Math.ceil(e.height / 4) * 4, f = Be[s], u = r.generateMipmaps || r.mips, { mipmapCount: l, outputSize: h, bufferRanges: m } = ye(c, n, f, u), R = (r.srgb || r.format?.endsWith("srgb")) && Ce(s);
+    let T = R ? A.sRGB : A.Linear;
+    Se(s) && (T |= A.Alpha), r.normal && (T = A.Normal);
+    const d = xe[s] + (R ? "-srgb" : ""), V = R ? ["rgba8unorm", "rgba8unorm-srgb"] : ["rgba8unorm"], x = this.#B++;
+    this.#G("create input texture #" + x);
+    let y = GPUTextureUsage.TEXTURE_BINDING | GPUTextureUsage.COPY_DST;
+    this.#h ? y |= GPUTextureUsage.RENDER_ATTACHMENT : y |= GPUTextureUsage.STORAGE_BINDING;
+    const S = r.flipY || c != e.width || n != e.height;
+    !S && !(e instanceof GPUTexture) && (y |= GPUTextureUsage.RENDER_ATTACHMENT);
+    const _ = this.#e.createCommandEncoder();
+    _.pushDebugGroup?.("spark process texture"), this.#n && typeof _.writeTimestamp == "function" && _.writeTimestamp(this.#n, 0);
+    let E;
+    if (S || !(e instanceof GPUTexture && !u)) {
+      const g = !this.#t || !this.#o || this.#o.width < c || this.#o.height < n || this.#o.mipLevelCount < l;
+      this.#t && this.#o && !g ? E = this.#o : (this.#t && this.#o && this.#o.destroy(), E = this.#e.createTexture({
+        size: [c, n, 1],
+        mipLevelCount: l,
+        format: "rgba8unorm",
+        usage: y,
+        viewFormats: V
+      }), this.#t && (this.#o = E));
+    }
+    let P;
+    if (S)
+      if (e instanceof GPUTexture)
+        this.#U(_, e, E, c, n, R, r.flipY);
+      else {
+        const g = !this.#t || !this.#c || this.#c.width < e.width || this.#c.height < e.height;
+        this.#t && this.#c && !g ? P = this.#c : (this.#t && this.#c && this.#c.destroy(), P = this.#e.createTexture({
+          size: [e.width, e.height, 1],
+          mipLevelCount: 1,
+          format: "rgba8unorm",
+          // RENDER_ATTACHMENT usage is necessary for copyExternalImageToTexture
+          usage: GPUTextureUsage.TEXTURE_BINDING | GPUTextureUsage.COPY_DST | GPUTextureUsage.RENDER_ATTACHMENT,
+          viewFormats: V
+        }), this.#t && (this.#c = P)), this.#e.queue.copyExternalImageToTexture({ source: e }, { texture: P }, { width: e.width, height: e.height }), this.#U(_, P, E, c, n, T, r.flipY);
+      }
+    else
+      e instanceof GPUTexture ? u ? _.copyTextureToTexture({ texture: e }, { texture: E }, { width: c, height: n }) : E = e : this.#e.queue.copyExternalImageToTexture({ source: e }, { texture: E }, { width: c, height: n });
+    u && this.#L(_, E, l, c, n, T, r.mipsAlphaScale, r.mipmapFilter), _.popDebugGroup?.(), this.#C("create input texture #" + x);
+    const W = r.outputTexture && r.outputTexture.width == c && r.outputTexture.height == n && r.outputTexture.mipLevelCount == l && r.outputTexture.format == d ? r.outputTexture : this.#e.createTexture({
+      size: [c, n, 1],
+      mipLevelCount: l,
+      format: d,
       usage: GPUTextureUsage.TEXTURE_BINDING | GPUTextureUsage.COPY_DST
-    }), U = this.#e.createBuffer({
+    });
+    let C;
+    this.#t && this.#m && this.#m.size >= h ? C = this.#m : (this.#t && this.#m && this.#m.destroy(), C = this.#e.createBuffer({
       size: h,
       usage: GPUBufferUsage.STORAGE | GPUBufferUsage.COPY_SRC
-    }), S = `dispatch compute shader '${G[s]}' #${x}`;
-    console.time(S), p.pushDebugGroup?.("spark encode texture");
-    let M = {};
-    this.#r && typeof p.writeTimestamp != "function" && (M = {
+    }), this.#t && (this.#m = C));
+    const k = `dispatch compute shader '${N[s]}' #${x}`;
+    this.#G(k), _.pushDebugGroup?.("spark encode texture");
+    let b = {};
+    this.#n && typeof _.writeTimestamp != "function" && (b = {
       writeTimestamps: {
-        querySet: this.#r,
+        querySet: this.#n,
         beginningOfPassWriteIndex: 0,
         endOfPassWriteIndex: 1
       }
     });
-    const v = await n, T = p.beginComputePass(M);
-    T.setPipeline(v);
-    for (let g = 0; g < f; g++) {
-      const z = this.#e.createBindGroup({
-        layout: v.getBindGroupLayout(0),
+    const U = await o, B = _.beginComputePass(b);
+    B.setPipeline(U);
+    for (let g = 0; g < l; g++) {
+      const L = this.#e.createBindGroup({
+        layout: U.getBindGroupLayout(0),
         entries: [
           {
             binding: 0,
-            resource: d.createView({
+            resource: E.createView({
               baseMipLevel: g,
               mipLevelCount: 1
             })
           },
           {
             binding: 1,
-            resource: this.#i
+            resource: this.#s
           },
           {
             binding: 2,
             resource: {
-              buffer: U,
+              buffer: C,
               offset: m[g].offset,
               size: m[g].size
             }
           }
         ]
       });
-      T.setBindGroup(0, z), T.dispatchWorkgroups(Math.ceil(m[g].bw / 16), Math.ceil(m[g].bh / 16));
+      B.setBindGroup(0, L), B.dispatchWorkgroups(Math.ceil(m[g].bw / 16), Math.ceil(m[g].bh / 16));
     }
-    T.end();
-    for (let g = 0; g < f; g++)
-      p.copyBufferToTexture(
+    B.end();
+    for (let g = 0; g < l; g++)
+      _.copyBufferToTexture(
         {
-          buffer: U,
+          buffer: C,
           offset: m[g].offset,
           bytesPerRow: m[g].bytesPerRow,
           rowsPerImage: m[g].bh
         },
         {
-          texture: E,
+          texture: W,
           mipLevel: g
         },
         {
@@ -647,7 +665,7 @@ class D {
           depthOrArrayLayers: 1
         }
       );
-    return this.#r && typeof p.writeTimestamp == "function" && p.writeTimestamp(this.#r, 1), p.popDebugGroup?.(), this.#e.queue.submit([p.finish()]), console.timeEnd(S), R?.destroy(), d != t && d?.destroy(), U?.destroy(), E;
+    return this.#n && typeof _.writeTimestamp == "function" && _.writeTimestamp(this.#n, 1), _.popDebugGroup?.(), this.#e.queue.submit([_.finish()]), this.#C(k), this.#t || (P?.destroy(), E != e && E?.destroy(), C?.destroy()), W;
   }
   /**
    * Returns the time (in milliseconds) it took to perform the most recent `encodeTexture()` call.
@@ -669,74 +687,71 @@ class D {
    * @throws {Error} If the GPU work has not been submitted, or if timestamp queries fail.
    */
   async getTimeElapsed() {
-    if (!this.#r)
+    if (!this.#n)
       return 0;
-    const e = this.#e.createCommandEncoder();
-    e.resolveQuerySet(this.#r, 0, 2, this.#p, 0), e.copyBufferToBuffer(this.#p, 0, this.#c, 0, 16), this.#e.queue.submit([e.finish()]), await this.#e.queue.onSubmittedWorkDone(), await this.#c.mapAsync(GPUMapMode.READ);
-    const r = this.#c.getMappedRange(), t = new BigUint64Array(r), s = t[0], n = t[1];
-    return this.#c.unmap(), Number(n - s) / 1e6;
+    const t = this.#e.createCommandEncoder();
+    t.resolveQuerySet(this.#n, 0, 2, this.#_, 0), t.copyBufferToBuffer(this.#_, 0, this.#u, 0, 16), this.#e.queue.submit([t.finish()]), await this.#e.queue.onSubmittedWorkDone(), await this.#u.mapAsync(GPUMapMode.READ);
+    const r = this.#u.getMappedRange(), e = new BigUint64Array(r), s = e[0], o = e[1];
+    return this.#u.unmap(), Number(o - s) / 1e6;
   }
-  async #B(e, r, t) {
-    w(e, "device is required"), w(H(e), "device is not a WebGPU device"), this.#e = e, this.#f = Q(this.#e), this.#i = this.#e.createSampler({
+  async #w(t, r, e, s, o) {
+    if (O(t, "device is required"), O(Pe(t), "device is not a WebGPU device"), this.#e = t, this.#b = s, this.#t = o, this.#l = Ue(this.#e), this.#s = this.#e.createSampler({
       magFilter: "linear",
       minFilter: "linear"
-    });
-    for (let s = 0; s < 3; s++)
-      this.#n[s] = this.#e.createBuffer({
-        size: 4,
-        usage: GPUBufferUsage.UNIFORM | GPUBufferUsage.COPY_DST
-      }), this.#e.queue.writeBuffer(this.#n[s], 0, new Uint32Array([s]));
-    if (t && this.#e.features.has("timestamp-query")) {
-      const s = O(), n = k();
-      (!s || s >= 26) && !n && (this.#r = this.#e.createQuerySet({
+    }), this.#i = this.#e.createBuffer({
+      size: 16,
+      usage: GPUBufferUsage.UNIFORM | GPUBufferUsage.COPY_DST
+    }), e && this.#e.features.has("timestamp-query")) {
+      const c = he(), n = J();
+      (!c || c >= 26) && !n && (this.#n = this.#e.createQuerySet({
         type: "timestamp",
         count: 2
-      }), this.#p = this.#e.createBuffer({
+      }), this.#_ = this.#e.createBuffer({
         size: 16,
         // 2 timestamps × 8 bytes each
         usage: GPUBufferUsage.COPY_SRC | GPUBufferUsage.QUERY_RESOLVE
-      }), this.#c = this.#e.createBuffer({
+      }), this.#u = this.#e.createBuffer({
         size: 16,
         // 2 timestamps × 8 bytes each
         usage: GPUBufferUsage.COPY_DST | GPUBufferUsage.MAP_READ
       }));
     }
-    if (this.#g = this.#e.features.has("shader-f16"), await this.#C(), r) {
-      let s;
-      Array.isArray(r) ? s = r.map((n) => this.#b(n, !1)) : s = this.#f;
-      for (const n of s)
-        n !== void 0 && !this.#l[n] && this.#h(n).catch((a) => {
-          console.error(`Failed to preload pipeline for format ${n}:`, a);
+    if (this.#T = this.#e.features.has("shader-f16"), await this.#y(), r) {
+      let c;
+      Array.isArray(r) ? c = r.map((n) => this.#P(n, !1)) : c = this.#l;
+      for (const n of c)
+        n !== void 0 && !this.#f[n] && this.#S(n).catch((f) => {
+          console.error(`Failed to preload pipeline for format ${n}:`, f);
         });
     }
   }
-  async #C() {
-    const e = this.#e.createShaderModule({
-      code: await I["utils.wgsl"](),
+  async #y() {
+    const t = this.#e.createShaderModule({
+      code: await Z["utils.wgsl"](),
       label: "utils"
     });
-    if (typeof e.compilationInfo == "function") {
-      const t = await e.compilationInfo();
-      if (t.messages.some((s) => s.type == "error")) {
+    if (typeof t.compilationInfo == "function") {
+      const e = await t.compilationInfo();
+      if (e.messages.some((s) => s.type == "error")) {
         console.error("WGSL compilation errors:");
-        for (const s of t.messages)
+        for (const s of e.messages)
           console.error(s);
         throw new Error("Shader compilation failed");
       }
     }
-    if (k() && (this.#a = !0), this.#a) {
-      this.#s = {}, this.#o = {}, this.#u = {};
-      const t = ["rgba8unorm-srgb", "rgba8unorm"];
-      for (const s of t)
-        this.#s[s] = this.#e.createRenderPipeline({
+    if (J() && (this.#h = !0), this.#h) {
+      this.#g = {}, this.#p = {}, this.#a = {};
+      const e = ["rgba8unorm-srgb", "rgba8unorm"];
+      for (const s of e)
+        this.#g[s] = this.#e.createRenderPipeline({
           label: `mipmap-pipeline-${s}`,
           layout: "auto",
           vertex: {
-            module: e,
+            module: t,
             entryPoint: "fullscreen_vs"
           },
           fragment: {
-            module: e,
+            module: t,
             entryPoint: "mipmap_fs",
             targets: [{ format: s }]
           },
@@ -744,15 +759,15 @@ class D {
             topology: "triangle-strip",
             stripIndexFormat: "uint32"
           }
-        }), this.#o[s] = this.#e.createRenderPipeline({
+        }), this.#p[s] = this.#e.createRenderPipeline({
           label: `resize-pipeline-${s}`,
           layout: "auto",
           vertex: {
-            module: e,
+            module: t,
             entryPoint: "fullscreen_vs"
           },
           fragment: {
-            module: e,
+            module: t,
             entryPoint: "resize_fs",
             targets: [{ format: s }]
           },
@@ -760,15 +775,15 @@ class D {
             topology: "triangle-strip",
             stripIndexFormat: "uint32"
           }
-        }), this.#u[s] = this.#e.createRenderPipeline({
+        }), this.#a[s] = this.#e.createRenderPipeline({
           label: `flip-y-pipeline-${s}`,
           layout: "auto",
           vertex: {
-            module: e,
+            module: t,
             entryPoint: "fullscreen_vs"
           },
           fragment: {
-            module: e,
+            module: t,
             entryPoint: "flipy_fs",
             targets: [{ format: s }]
           },
@@ -778,204 +793,186 @@ class D {
           }
         });
     } else
-      this.#s = this.#e.createComputePipeline({
+      this.#g = this.#e.createComputePipeline({
         layout: "auto",
         compute: {
-          module: e,
+          module: t,
           entryPoint: "mipmap"
         }
-      }), this.#o = this.#e.createComputePipeline({
+      }), this.#d = this.#e.createComputePipeline({
         layout: "auto",
         compute: {
-          module: e,
+          module: t,
+          entryPoint: "magic_mipmap"
+        }
+      }), this.#p = this.#e.createComputePipeline({
+        layout: "auto",
+        compute: {
+          module: t,
           entryPoint: "resize"
         }
-      }), this.#u = this.#e.createComputePipeline({
+      }), this.#a = this.#e.createComputePipeline({
         layout: "auto",
         compute: {
-          module: e,
+          module: t,
           entryPoint: "flipy"
         }
       });
-    this.#m = await this.#e.createComputePipelineAsync({
+    this.#E = await this.#e.createComputePipelineAsync({
       layout: "auto",
       compute: {
-        module: e,
+        module: t,
         entryPoint: "detect_channel_count"
       }
     });
   }
-  async #h(e) {
-    if (this.#l[e])
-      return this.#l[e];
+  #S(t) {
+    if (this.#f[t])
+      return this.#f[t];
     const r = (async () => {
-      console.time("loadPipeline " + G[e]);
-      const t = q[e];
-      w(t, `No shader available for format ${G[e]}`);
-      let s = await I[t]();
-      this.#g || (s = s.replace(/^enable f16;\s*/m, "").replace(/\bf16\b/g, "f32").replace(/\bvec([234])h\b/g, "vec$1f").replace(/\bmat([234]x[234])h/g, "mat$1f").replace(/\b(\d*\.\d+|\d+\.)h\b/g, "$1"));
-      const n = this.#e.createShaderModule({
+      this.#G("loadPipeline " + N[t]);
+      const e = Re[t];
+      O(e, `No shader available for format ${N[t]}`);
+      let s = await Z[e]();
+      this.#T || (s = s.replace(/^enable f16;\s*/m, "").replace(/\bf16\b/g, "f32").replace(/\bvec([234])h\b/g, "vec$1f").replace(/\bmat([234]x[234])h/g, "mat$1f").replace(/\b(\d*\.\d+|\d+\.)h\b/g, "$1"));
+      const o = this.#e.createShaderModule({
         code: s,
-        label: G[e]
+        label: N[t]
       });
-      if (typeof n.getCompilationInfo == "function") {
-        const o = await n.getCompilationInfo();
-        if (o.messages.some((u) => u.type == "error")) {
+      if (typeof o.getCompilationInfo == "function") {
+        const n = await o.getCompilationInfo();
+        if (n.messages.some((f) => f.type == "error")) {
           console.error("WGSL compilation errors:");
-          for (const u of o.messages)
-            console.error(u);
+          for (const f of n.messages)
+            console.error(f);
           throw new Error("Shader compilation failed");
         }
       }
-      const a = await this.#e.createComputePipelineAsync({
+      const c = await this.#e.createComputePipelineAsync({
         layout: "auto",
         compute: {
-          module: n,
+          module: o,
           entryPoint: "main"
         }
       });
-      return console.timeEnd("loadPipeline " + G[e]), a;
+      return this.#C("loadPipeline " + N[t]), c;
     })();
-    return this.#l[e] = r, r;
+    return this.#f[t] = r, r;
   }
-  #t(e) {
-    return this.#f.has(e);
+  #r(t) {
+    return this.#l.has(t);
   }
-  #b(e, r) {
-    const t = P[e];
-    if (t != null && this.#t(t))
-      return t;
-    const s = r ? [
-      "bc4-r",
-      "eac-r",
-      "bc5-rg",
-      "eac-rg",
-      "bc1-rgb",
-      "etc2-rgb",
-      "bc7-rgb",
-      "astc-rgb",
-      "astc-4x4-rgb",
-      "bc7-rgba",
-      "astc-rgba",
-      "astc-4x4-rgba"
-    ] : [
-      "bc4-r",
-      "eac-r",
-      "bc5-rg",
-      "eac-rg",
-      "bc7-rgb",
-      "bc1-rgb",
-      "astc-rgb",
-      "astc-4x4-rgb",
-      "etc2-rgb",
-      "bc7-rgba",
-      "astc-rgba",
-      "astc-4x4-rgba"
-    ];
-    for (const n of s)
-      if (n.includes(e) && this.#t(P[n]))
-        return P[n];
+  #P(t, r) {
+    const e = z[t];
+    if (e != null && this.#r(e))
+      return e;
+    const s = r ? ["bc4-r", "eac-r", "bc5-rg", "eac-rg", "bc1-rgb", "etc2-rgb", "bc7-rgb", "astc-rgb", "astc-4x4-rgb", "bc7-rgba", "astc-rgba", "astc-4x4-rgba"] : ["bc4-r", "eac-r", "bc5-rg", "eac-rg", "bc7-rgb", "astc-rgb", "astc-4x4-rgb", "bc1-rgb", "etc2-rgb", "bc7-rgba", "astc-rgba", "astc-4x4-rgba"];
+    for (const o of s)
+      if (o.includes(t) && this.#r(z[o]))
+        return z[o];
   }
-  async #d(e, r) {
-    if (e.format == null)
-      e.format = "rgb";
-    else if (e.format == "auto") {
-      if (e.alpha) {
-        if (this.#t(i.BC7_RGBA)) return i.BC7_RGBA;
-        if (this.#t(i.ASTC_4x4_RGBA)) return i.ASTC_4x4_RGBA;
-      } else if (e.srgb) {
-        if (this.#t(i.BC7_RGB)) return i.BC7_RGB;
-        if (this.#t(i.ASTC_4x4_RGB)) return i.ASTC_4x4_RGB;
-        if (this.#t(i.BC1_RGB)) return i.BC1_RGB;
-        if (this.#t(i.ETC2_RGB)) return i.ETC2_RGB;
-      } else if (e.normal) {
-        if (this.#t(i.BC5_RG)) return i.BC5_RG;
-        if (this.#t(i.EAC_RG)) return i.EAC_RG;
+  async #A(t, r) {
+    if (t.format == null)
+      t.format = "rgb";
+    else if (t.format == "auto") {
+      if (t.srgb) {
+        if (this.#r(a.BC7_RGB)) return a.BC7_RGB;
+        if (this.#r(a.ASTC_4x4_RGB)) return a.ASTC_4x4_RGB;
+        if (this.#r(a.BC1_RGB)) return a.BC1_RGB;
+        if (this.#r(a.ETC2_RGB)) return a.ETC2_RGB;
+      } else if (t.normal) {
+        if (this.#r(a.BC5_RG)) return a.BC5_RG;
+        if (this.#r(a.EAC_RG)) return a.EAC_RG;
       } else {
         let s;
         if (r instanceof GPUTexture)
-          r.format == "r8unorm" || r.format == "r16unorm" ? s = 1 : r.format == "rg8unorm" || r.format == "rg16unorm" ? s = 2 : s = await this.#T(r);
+          r.format == "r8unorm" || r.format == "r16unorm" ? s = 1 : r.format == "rg8unorm" || r.format == "rg16unorm" ? s = 2 : s = await this.#F(r);
         else {
-          const n = Z(r);
-          s = this.#R(n);
+          const o = we(r);
+          s = this.#I(o);
         }
         if (s == 4) {
-          if (this.#t(i.BC7_RGBA)) return i.BC7_RGBA;
-          if (this.#t(i.ASTC_4x4_RGBA)) return i.ASTC_4x4_RGBA;
+          if (this.#r(a.BC7_RGBA)) return a.BC7_RGBA;
+          if (this.#r(a.ASTC_4x4_RGBA)) return a.ASTC_4x4_RGBA;
         } else if (s == 3) {
-          if (this.#t(i.BC7_RGB)) return i.BC7_RGB;
-          if (this.#t(i.ASTC_4x4_RGB)) return i.ASTC_4x4_RGB;
-          if (this.#t(i.BC1_RGB)) return i.BC1_RGB;
-          if (this.#t(i.ETC2_RGB)) return i.ETC2_RGB;
+          if (this.#r(a.BC7_RGB)) return a.BC7_RGB;
+          if (this.#r(a.ASTC_4x4_RGB)) return a.ASTC_4x4_RGB;
+          if (this.#r(a.BC1_RGB)) return a.BC1_RGB;
+          if (this.#r(a.ETC2_RGB)) return a.ETC2_RGB;
         } else if (s == 2) {
-          if (this.#t(i.BC5_RG)) return i.BC5_RG;
-          if (this.#t(i.EAC_RG)) return i.EAC_RG;
+          if (this.#r(a.BC5_RG)) return a.BC5_RG;
+          if (this.#r(a.EAC_RG)) return a.EAC_RG;
         } else if (s == 1) {
-          if (this.#t(i.BC4_R)) return i.BC4_R;
-          if (this.#t(i.EAC_R)) return i.EAC_R;
+          if (this.#r(a.BC4_R)) return a.BC4_R;
+          if (this.#r(a.EAC_R)) return a.EAC_R;
         }
       }
       throw new Error("No supported format found.");
     }
-    const t = this.#b(e.format, e.preferLowQuality);
-    if (t === void 0)
-      throw new Error(`Unsupported format: ${e.format}`);
-    return t;
+    const e = this.#P(t.format, t.preferLowQuality);
+    if (e === void 0)
+      throw new Error(`Unsupported format: ${t.format}`);
+    return e;
   }
-  #R(e) {
-    let r = !0, t = !0, s = 0;
-    const n = Math.min(1024 * 128, e.length);
-    for (let a = 0; a < n; a += 4) {
-      const o = e[a] / 255, u = e[a + 1] / 255, l = e[a + 2] / 255;
-      e[a + 3] < 255 && (r = !1), (o != u || u != l) && (t = !1);
-      const h = 2 * o - 1, m = 2 * u - 1, b = 2 * l - 1, _ = h * h + m * m + b * b, B = Math.sqrt(_);
-      (Math.abs(B - 1) > 0.2 || b < -0.1) && (s += 1);
+  #I(t) {
+    let r = !0, e = !0, s = 0;
+    const o = Math.min(1024 * 128, t.length);
+    for (let c = 0; c < o; c += 4) {
+      const n = t[c] / 255, f = t[c + 1] / 255, u = t[c + 2] / 255;
+      t[c + 3] < 255 && (r = !1), (n != f || f != u) && (e = !1);
+      const h = 2 * n - 1, m = 2 * f - 1, R = 2 * u - 1, T = h * h + m * m + R * R, d = Math.sqrt(T);
+      (Math.abs(d - 1) > 0.2 || R < -0.1) && (s += 1);
     }
-    return r ? t ? 1 : 16 * s < n ? 2 : 3 : 4;
+    return r ? e ? 1 : 16 * s < o ? 2 : 3 : 4;
   }
-  async #T(e) {
-    const t = this.#e.createBuffer({
+  async #F(t) {
+    const e = this.#e.createBuffer({
       size: 12,
       usage: GPUBufferUsage.STORAGE | GPUBufferUsage.COPY_SRC
     }), s = this.#e.createBuffer({
       size: 12,
       usage: GPUBufferUsage.COPY_DST | GPUBufferUsage.MAP_READ
-    }), n = this.#e.createBindGroup({
-      layout: this.#m.getBindGroupLayout(0),
+    }), o = this.#e.createBindGroup({
+      layout: this.#E.getBindGroupLayout(0),
       entries: [
-        { binding: 0, resource: e.createView() },
-        { binding: 1, resource: { buffer: t } }
+        { binding: 0, resource: t.createView() },
+        { binding: 1, resource: { buffer: e } }
       ]
-    }), a = this.#e.createCommandEncoder(), o = a.beginComputePass();
-    o.setPipeline(this.#m), o.setBindGroup(0, n);
-    const { width: u, height: l } = e, f = Math.ceil(u / 8), h = Math.ceil(l / 8);
-    o.dispatchWorkgroups(f, h), o.end(), a.copyBufferToBuffer(t, 0, s, 0, 12), this.#e.queue.submit([a.finish()]), await this.#e.queue.onSubmittedWorkDone(), await s.mapAsync(GPUMapMode.READ);
-    const m = new Uint32Array(s.getMappedRange()), b = m[0] == 0, _ = m[1] == 0, B = m[2];
-    return s.unmap(), s.destroy(), t.destroy(), b ? _ ? 1 : 4 * B < u * l ? 2 : 3 : 4;
+    }), c = this.#e.createCommandEncoder(), n = c.beginComputePass();
+    n.setPipeline(this.#E), n.setBindGroup(0, o);
+    const { width: f, height: u } = t, l = Math.ceil(f / 8), h = Math.ceil(u / 8);
+    n.dispatchWorkgroups(l, h), n.end(), c.copyBufferToBuffer(e, 0, s, 0, 12), this.#e.queue.submit([c.finish()]), await this.#e.queue.onSubmittedWorkDone(), await s.mapAsync(GPUMapMode.READ);
+    const m = new Uint32Array(s.getMappedRange()), R = m[0] == 0, T = m[1] == 0, d = m[2];
+    return s.unmap(), s.destroy(), e.destroy(), R ? T ? 1 : 4 * d < f * u ? 2 : 3 : 4;
+  }
+  #R(t, r, e) {
+    const s = r && r.length > 0 ? e < r.length ? r[e] : r[r.length - 1] : 1, o = new ArrayBuffer(8), c = new DataView(o);
+    c.setUint32(0, t, !0), c.setFloat32(4, s, !0), this.#e.queue.writeBuffer(this.#i, 0, o);
   }
   // Apply scaling and flipY transform.
-  #_(e, r, t, s, n, a, o) {
-    if (this.#a) {
-      this.#P(e, r, t, s, n, a, o);
+  #U(t, r, e, s, o, c, n) {
+    if (this.#h) {
+      this.#M(t, r, e, s, o, c, n);
       return;
     }
-    const u = e.beginComputePass(), l = o ? this.#u : this.#o;
-    u.setPipeline(l);
-    const f = this.#e.createBindGroup({
-      layout: l.getBindGroupLayout(0),
+    this.#R(c);
+    const f = t.beginComputePass(), u = n ? this.#a : this.#p;
+    f.setPipeline(u);
+    const l = this.#e.createBindGroup({
+      layout: u.getBindGroupLayout(0),
       entries: [
         {
           binding: 0,
           resource: r.createView({
             baseMipLevel: 0,
             mipLevelCount: 1,
-            format: a == 1 ? "rgba8unorm-srgb" : "rgba8unorm",
+            format: (c & A.sRGB) != 0 ? "rgba8unorm-srgb" : "rgba8unorm",
             usage: GPUTextureUsage.TEXTURE_BINDING
           })
         },
         {
           binding: 1,
-          resource: t.createView({
+          resource: e.createView({
             baseMipLevel: 0,
             mipLevelCount: 1,
             dimension: "2d",
@@ -985,35 +982,37 @@ class D {
         },
         {
           binding: 2,
-          resource: this.#i
+          resource: this.#s
         },
         {
           binding: 3,
-          resource: { buffer: this.#n[a] }
+          resource: { buffer: this.#i }
         }
       ]
     });
-    u.setBindGroup(0, f), u.dispatchWorkgroups(Math.ceil(s / 8), Math.ceil(n / 8)), u.end();
+    f.setBindGroup(0, l), f.dispatchWorkgroups(Math.ceil(s / 8), Math.ceil(o / 8)), f.end();
   }
   // Apply scaling and flipY transform.
-  #P(e, r, t, s, n, a, o) {
-    const u = a == 1 ? "rgba8unorm-srgb" : "rgba8unorm", l = t.createView({
+  #M(t, r, e, s, o, c, n) {
+    const f = (c & A.sRGB) != 0 ? "rgba8unorm-srgb" : "rgba8unorm", u = e.createView({
       baseMipLevel: 0,
       mipLevelCount: 1,
       dimension: "2d",
-      format: u,
+      format: f,
       usage: GPUTextureUsage.RENDER_ATTACHMENT
-    }), f = e.beginRenderPass({
+    }), l = t.beginRenderPass({
       colorAttachments: [
         {
-          view: l,
+          view: u,
           loadOp: "clear",
           storeOp: "store",
           clearValue: [0, 0, 0, 0]
         }
       ]
-    }), h = o ? this.#u[u] : this.#o[u];
-    f.setPipeline(h);
+    });
+    this.#R(c);
+    const h = n ? this.#a[f] : this.#p[f];
+    l.setPipeline(h);
     const m = this.#e.createBindGroup({
       layout: h.getBindGroupLayout(0),
       entries: [
@@ -1022,52 +1021,53 @@ class D {
           resource: r.createView({
             baseMipLevel: 0,
             mipLevelCount: 1,
-            format: a == 1 ? "rgba8unorm-srgb" : "rgba8unorm",
+            format: (c & A.sRGB) != 0 ? "rgba8unorm-srgb" : "rgba8unorm",
             usage: GPUTextureUsage.TEXTURE_BINDING
           })
         },
         {
           binding: 2,
-          resource: this.#i
+          resource: this.#s
         },
         {
           binding: 3,
-          resource: { buffer: this.#n[a] }
+          resource: { buffer: this.#i }
         }
       ]
     });
-    f.setBindGroup(0, m), f.draw(4, 1, 0, 0), f.end();
+    l.setBindGroup(0, m), l.draw(4, 1, 0, 0), l.end();
   }
-  async #w(e, r, t, s, n, a) {
-    let o = s, u = n;
-    if (this.#a)
-      for (let l = 0; l < t - 1; l++)
-        o = Math.max(1, Math.floor(o / 2)), u = Math.max(1, Math.floor(u / 2)), this.#y(e, r, l, l + 1, o, u, a);
+  async #L(t, r, e, s, o, c, n, f) {
+    n == null && this.#R(c);
+    let u = s, l = o;
+    if (this.#h)
+      for (let h = 0; h < e - 1; h++)
+        n != null && this.#R(c, n, h), u = Math.max(1, Math.floor(u / 2)), l = Math.max(1, Math.floor(l / 2)), this.#N(t, r, h, h + 1, u, l, c);
     else {
-      const l = e.beginComputePass();
-      l.setPipeline(this.#s);
-      for (let f = 0; f < t - 1; f++)
-        o = Math.max(1, Math.floor(o / 2)), u = Math.max(1, Math.floor(u / 2)), this.#x(l, r, f, f + 1, o, u, a);
-      l.end();
+      const h = t.beginComputePass(), m = f === "box" || (c & A.Alpha) != 0 ? this.#g : this.#d, R = m.getBindGroupLayout(0);
+      h.setPipeline(m);
+      for (let T = 0; T < e - 1; T++)
+        n != null && this.#R(c, n, T), u = Math.max(1, Math.floor(u / 2)), l = Math.max(1, Math.floor(l / 2)), this.#D(h, R, r, T, T + 1, u, l, c);
+      h.end();
     }
   }
-  #x(e, r, t, s, n, a, o) {
+  #D(t, r, e, s, o, c, n, f) {
     const u = this.#e.createBindGroup({
-      layout: this.#s.getBindGroupLayout(0),
+      layout: r,
       entries: [
         {
           binding: 0,
-          resource: r.createView({
-            baseMipLevel: t,
+          resource: e.createView({
+            baseMipLevel: s,
             mipLevelCount: 1,
-            format: o == 1 ? "rgba8unorm-srgb" : "rgba8unorm",
+            format: (f & A.sRGB) != 0 ? "rgba8unorm-srgb" : "rgba8unorm",
             usage: GPUTextureUsage.TEXTURE_BINDING
           })
         },
         {
           binding: 1,
-          resource: r.createView({
-            baseMipLevel: s,
+          resource: e.createView({
+            baseMipLevel: o,
             mipLevelCount: 1,
             dimension: "2d",
             format: "rgba8unorm",
@@ -1076,57 +1076,581 @@ class D {
         },
         {
           binding: 2,
-          resource: this.#i
+          resource: this.#s
         },
         {
           binding: 3,
-          resource: { buffer: this.#n[o] }
+          resource: { buffer: this.#i }
         }
       ]
     });
-    e.setBindGroup(0, u), e.dispatchWorkgroups(Math.ceil(n / 8), Math.ceil(a / 8));
+    t.setBindGroup(0, u), t.dispatchWorkgroups(Math.ceil(c / 8), Math.ceil(n / 8));
   }
-  #y(e, r, t, s, n, a, o) {
-    const u = o == 1 ? "rgba8unorm-srgb" : "rgba8unorm", l = r.createView({
+  #N(t, r, e, s, o, c, n) {
+    const f = (n & A.sRGB) != 0 ? "rgba8unorm-srgb" : "rgba8unorm", u = r.createView({
       baseMipLevel: s,
       mipLevelCount: 1,
       dimension: "2d",
-      format: u,
+      format: f,
       usage: GPUTextureUsage.RENDER_ATTACHMENT
-    }), f = e.beginRenderPass({
+    }), l = t.beginRenderPass({
       colorAttachments: [
         {
-          view: l,
+          view: u,
           loadOp: "clear",
           storeOp: "store",
           clearValue: [0, 0, 0, 0]
         }
       ]
     }), h = this.#e.createBindGroup({
-      layout: this.#s[u].getBindGroupLayout(0),
+      layout: this.#g[f].getBindGroupLayout(0),
       entries: [
         {
           binding: 0,
           resource: r.createView({
-            baseMipLevel: t,
+            baseMipLevel: e,
             mipLevelCount: 1,
-            format: u,
+            format: f,
             usage: GPUTextureUsage.TEXTURE_BINDING
           })
         },
         {
           binding: 2,
-          resource: this.#i
+          resource: this.#s
         },
         {
           binding: 3,
-          resource: { buffer: this.#n[o] }
+          resource: { buffer: this.#i }
         }
       ]
     });
-    f.setPipeline(this.#s[u]), f.setBindGroup(0, h), f.draw(4, 1, 0, 0), f.end();
+    l.setPipeline(this.#g[f]), l.setBindGroup(0, h), l.draw(4, 1, 0, 0), l.end();
+  }
+}
+const Ie = /* @__PURE__ */ Object.assign({ "./spark_astc_rgb.glsl": () => import("./spark_astc_rgb-CTmg8wnA.js").then((i) => i.default), "./spark_astc_rgba.glsl": () => import("./spark_astc_rgba-CDMNWH6H.js").then((i) => i.default), "./spark_bc1_rgb.glsl": () => import("./spark_bc1_rgb-C0pbbQPO.js").then((i) => i.default), "./spark_bc4_r.glsl": () => import("./spark_bc4_r-YQ6i79H9.js").then((i) => i.default), "./spark_bc5_rg.glsl": () => import("./spark_bc5_rg-BqzKgeMU.js").then((i) => i.default), "./spark_bc7_rgb.glsl": () => import("./spark_bc7_rgb-DBkDHCzE.js").then((i) => i.default), "./spark_bc7_rgba.glsl": () => import("./spark_bc7_rgba-DQUk89UX.js").then((i) => i.default), "./spark_eac_r.glsl": () => import("./spark_eac_r-Dvy2qUxf.js").then((i) => i.default), "./spark_eac_rg.glsl": () => import("./spark_eac_rg-DKLVL9co.js").then((i) => i.default), "./spark_etc2_rgb.glsl": () => import("./spark_etc2_rgb-BpnNweVx.js").then((i) => i.default) }), Fe = Object.fromEntries(
+  Object.entries(Ie).map(([i, t]) => [i.replace("./", ""), async () => await t()])
+), p = {
+  ASTC_4x4_RGB: 0,
+  ASTC_4x4_RGBA: 1,
+  EAC_R: 4,
+  EAC_RG: 5,
+  ETC2_RGB: 6,
+  BC1_RGB: 9,
+  BC4_R: 13,
+  BC5_RG: 14,
+  BC7_RGB: 16,
+  BC7_RGBA: 17
+}, v = [
+  /* 0  */
+  "astc-4x4-rgb",
+  /* 1  */
+  "astc-4x4-rgba",
+  /* 2  */
+  null,
+  /* 3  */
+  null,
+  /* 4  */
+  "eac-r",
+  /* 5  */
+  "eac-rg",
+  /* 6  */
+  "etc2-rgb",
+  /* 7  */
+  null,
+  /* 8  */
+  null,
+  /* 9  */
+  "bc1-rgb",
+  /* 10 */
+  null,
+  /* 11 */
+  null,
+  /* 12 */
+  null,
+  /* 13 */
+  "bc4-r",
+  /* 14 */
+  "bc5-rg",
+  /* 15 */
+  null,
+  /* 16 */
+  "bc7-rgb",
+  /* 17 */
+  "bc7-rgba"
+], Me = [
+  /* 0  */
+  "spark_astc_rgb.glsl",
+  /* 1  */
+  "spark_astc_rgba.glsl",
+  /* 2  */
+  null,
+  /* 3  */
+  null,
+  /* 4  */
+  "spark_eac_r.glsl",
+  /* 5  */
+  "spark_eac_rg.glsl",
+  /* 6  */
+  "spark_etc2_rgb.glsl",
+  /* 7  */
+  null,
+  /* 8  */
+  null,
+  /* 9  */
+  "spark_bc1_rgb.glsl",
+  /* 10 */
+  null,
+  /* 11 */
+  null,
+  /* 12 */
+  null,
+  /* 13 */
+  "spark_bc4_r.glsl",
+  /* 14 */
+  "spark_bc5_rg.glsl",
+  /* 15 */
+  null,
+  /* 16 */
+  "spark_bc7_rgb.glsl",
+  /* 17 */
+  "spark_bc7_rgba.glsl"
+], Le = [
+  /* 0  */
+  16,
+  /* 1  */
+  16,
+  /* 2  */
+  0,
+  /* 3  */
+  0,
+  /* 4  */
+  8,
+  /* 5  */
+  16,
+  /* 6  */
+  8,
+  /* 7  */
+  0,
+  /* 8  */
+  0,
+  /* 9  */
+  8,
+  /* 10 */
+  0,
+  /* 11 */
+  0,
+  /* 12 */
+  0,
+  /* 13 */
+  8,
+  /* 14 */
+  16,
+  /* 15 */
+  0,
+  /* 16 */
+  16,
+  /* 17 */
+  16
+], De = [
+  /* 0  */
+  !0,
+  // ASTC_4x4_RGB
+  /* 1  */
+  !0,
+  // ASTC_4x4_RGBA
+  /* 2  */
+  null,
+  /* 3  */
+  null,
+  /* 4  */
+  !1,
+  // EAC_R
+  /* 5  */
+  !1,
+  // EAC_RG
+  /* 6  */
+  !0,
+  // ETC2_RGB
+  /* 7  */
+  null,
+  /* 8  */
+  null,
+  /* 9  */
+  !0,
+  // BC1_RGB
+  /* 10 */
+  null,
+  /* 11 */
+  null,
+  /* 12 */
+  null,
+  /* 13 */
+  !1,
+  // BC4_R
+  /* 14 */
+  !1,
+  // BC5_RG
+  /* 15 */
+  null,
+  /* 16 */
+  !0,
+  // BC7_RGB
+  /* 17 */
+  !0
+  // BC7_RGBA
+], se = 37808, ie = 37840, ae = 36492, ne = 36493, Ne = 33776, ve = 35916, oe = 36283, ce = 36285, Xe = 37492, ke = 37493, ue = 37488, le = 37490, X = 36208, $ = 36214, Oe = [
+  /* 0  */
+  [se, ie],
+  /* 1  */
+  [se, ie],
+  /* 2  */
+  null,
+  /* 3  */
+  null,
+  /* 4  */
+  [ue, ue],
+  /* 5  */
+  [le, le],
+  /* 6  */
+  [Xe, ke],
+  /* 7  */
+  null,
+  /* 8  */
+  null,
+  /* 9  */
+  [Ne, ve],
+  /* 10 */
+  null,
+  /* 11 */
+  null,
+  /* 12 */
+  null,
+  /* 13 */
+  [oe, oe],
+  /* 14 */
+  [ce, ce],
+  /* 15 */
+  null,
+  /* 16 */
+  [ae, ne],
+  /* 17 */
+  [ae, ne]
+], Ve = [
+  /* 0  */
+  X,
+  /* 1  */
+  X,
+  /* 2  */
+  null,
+  /* 3  */
+  null,
+  /* 4  */
+  $,
+  /* 5  */
+  X,
+  /* 6  */
+  $,
+  /* 7  */
+  null,
+  /* 8  */
+  null,
+  /* 9  */
+  $,
+  /* 10 */
+  null,
+  /* 11 */
+  null,
+  /* 12 */
+  null,
+  /* 13 */
+  $,
+  /* 14 */
+  X,
+  /* 15 */
+  null,
+  /* 16 */
+  X,
+  /* 17 */
+  X
+], H = Object.freeze({
+  "astc-4x4-rgb": p.ASTC_4x4_RGB,
+  "astc-4x4-rgba": p.ASTC_4x4_RGBA,
+  "eac-r": p.EAC_R,
+  "eac-rg": p.EAC_RG,
+  "etc2-rgb": p.ETC2_RGB,
+  "bc1-rgb": p.BC1_RGB,
+  "bc4-r": p.BC4_R,
+  "bc5-rg": p.BC5_RG,
+  "bc7-rgb": p.BC7_RGB,
+  "bc7-rgba": p.BC7_RGBA,
+  "astc-rgb": p.ASTC_4x4_RGB,
+  "astc-rgba": p.ASTC_4x4_RGBA
+});
+function We(i, t = !1) {
+  const r = /* @__PURE__ */ new Set();
+  if (t) {
+    const u = i.getSupportedExtensions();
+    console.log("Available WebGL extensions:"), u && u.sort().forEach((l) => {
+      console.log(`  ${l}`);
+    }), console.log(`Total: ${u ? u.length : 0} extensions`), console.log("");
+  }
+  (i.getExtension("EXT_texture_compression_bptc") || i.getExtension("WEBGL_texture_compression_bptc")) && (r.add(p.BC7_RGB), r.add(p.BC7_RGBA));
+  const s = i.getExtension("WEBGL_compressed_texture_s3tc"), o = i.getExtension("WEBGL_compressed_texture_s3tc_srgb");
+  if ((s || o) && r.add(p.BC1_RGB), i.getExtension("EXT_texture_compression_rgtc") && (r.add(p.BC4_R), r.add(p.BC5_RG)), i.getExtension("WEBGL_compressed_texture_etc") && (r.add(p.ETC2_RGB), r.add(p.EAC_R), r.add(p.EAC_RG)), i.getExtension("WEBGL_compressed_texture_astc") && (r.add(p.ASTC_4x4_RGB), r.add(p.ASTC_4x4_RGBA)), t) {
+    console.log("Supported compression formats:");
+    const u = Array.from(r).map((l) => v[l]).filter(Boolean);
+    u.forEach((l) => {
+      console.log(`  ${l}`);
+    }), console.log(`Total: ${u.length} formats`), console.log("");
+  }
+  return r;
+}
+async function ze(i) {
+  const t = Fe[i];
+  if (!t)
+    throw new Error(`Shader not found: ${i}`);
+  let r = await t();
+  return r = `#version 300 es
+precision highp float;
+precision highp int;
+` + r, r;
+}
+const Y = `#version 300 es
+void main() {
+    vec2 uv = vec2((gl_VertexID << 1) & 2, gl_VertexID & 2);
+    gl_Position = vec4(uv * 2.0 - 1.0, 0.0, 1.0);
+}
+`;
+function q(i, t, r, e) {
+  const s = i.createShader(t);
+  if (i.shaderSource(s, r), i.compileShader(s), e && !i.getShaderParameter(s, i.COMPILE_STATUS)) {
+    const o = i.getShaderInfoLog(s);
+    throw i.deleteShader(s), new Error(`Shader compilation failed: ${o}`);
+  }
+  return s;
+}
+function fe(i, t, r, e) {
+  const s = i.createProgram();
+  if (i.attachShader(s, t), i.attachShader(s, r), i.linkProgram(s), e && !i.getProgramParameter(s, i.LINK_STATUS)) {
+    const o = i.getProgramInfoLog(s);
+    throw i.deleteProgram(s), new Error(`Program linking failed: ${o}`);
+  }
+  return s;
+}
+class de {
+  #e;
+  #l;
+  #T = [];
+  #h = !1;
+  #f = !1;
+  #g = 0;
+  #d;
+  #p = !1;
+  // Cached temporary resources for encodeTexture
+  #a = null;
+  #E = 0;
+  #s = null;
+  // For 8-byte per block formats
+  #i = null;
+  // For 16-byte per block formats
+  #n = 0;
+  #_ = 0;
+  #u = null;
+  constructor(t, r = {}) {
+    if (!t)
+      throw new Error("WebGL2 context is required");
+    this.#e = t, this.#h = r.verbose ?? !1, this.#f = r.validateShaders ?? !1, this.#p = r.cacheTempResources ?? !1, this.#l = We(t, this.#h), r.preload && this.#m(r.preload);
+  }
+  dispose() {
+    const t = this.#e;
+    this.#d && t.deleteShader(this.#d);
+    for (const r of this.#T)
+      t.deleteProgram(r);
+    this.freeTempResources();
+  }
+  /**
+   * Initialize the encoder by detecting available compression formats.
+   * @param {WebGL2RenderingContext} gl - WebGL2 context.
+   * @param {Object} options - Encoder options.
+   * @param {boolean|string[]} options.preload - Whether to preload all encoder pipelines, or an array of format names to preload (false by default).
+   * @param {boolean} options.verbose - Whether to enable verbose logging (false by default).
+   * @param {boolean} options.cacheTempResources - Whether to cache temporary resources for reuse across encodeTexture calls (false by default).
+   * @returns {SparkGL} A new SparkGL instance.
+   */
+  static create(t, r = {}) {
+    return new de(t, r);
+  }
+  #t(...t) {
+    this.#h && console.log(...t);
+  }
+  #o(t) {
+    this.#h && console.time(t);
+  }
+  #c(t) {
+    this.#h && console.timeEnd(t);
+  }
+  async #m(t) {
+    let r;
+    Array.isArray(t) ? r = t.map((e) => this.#b(e, !1)) : r = this.#l;
+    for (const e of r)
+      e !== void 0 && !this.#T[e] && this.#x(e).catch((s) => {
+        console.error(`Failed to preload program for format ${v[e]}:`, s);
+      });
+  }
+  getSupportedFormats() {
+    return Array.from(this.#l).map((t) => v[t]).filter(Boolean);
+  }
+  isFormatSupported(t) {
+    const r = typeof t == "string" ? H[t] : t;
+    return this.#l.has(r);
+  }
+  /**
+   * Free cached temporary resources used by encodeTexture.
+   * Call this when you're done encoding textures to free up GPU memory.
+   */
+  freeTempResources() {
+    const t = this.#e;
+    this.#a && (t.deleteBuffer(this.#a), this.#a = null, this.#E = 0), this.#s && (t.deleteTexture(this.#s), this.#s = null), this.#i && (t.deleteTexture(this.#i), this.#i = null), this.#u && (t.deleteFramebuffer(this.#u), this.#u = null), this.#n = 0, this.#_ = 0;
+  }
+  #B(t) {
+    return this.#l.has(t);
+  }
+  #b(t, r = !1) {
+    const e = H[t];
+    if (e != null && this.#B(e))
+      return e;
+    const s = r ? ["bc4-r", "eac-r", "bc5-rg", "eac-rg", "bc1-rgb", "etc2-rgb", "bc7-rgb", "astc-rgb", "astc-4x4-rgb", "bc7-rgba", "astc-rgba", "astc-4x4-rgba"] : ["bc4-r", "eac-r", "bc5-rg", "eac-rg", "bc7-rgb", "astc-rgb", "astc-4x4-rgb", "bc1-rgb", "etc2-rgb", "bc7-rgba", "astc-rgba", "astc-4x4-rgba"];
+    for (const o of s)
+      if (o.includes(t) && this.#B(H[o]))
+        return H[o];
+  }
+  #x(t) {
+    if (this.#T[t])
+      return this.#T[t];
+    const r = (async () => {
+      const e = "Loading program for format: " + v[t];
+      this.#o(e);
+      const s = this.#e, o = Me[t];
+      this.#d || (this.#d = q(s, s.VERTEX_SHADER, Y, this.#f));
+      const c = await ze(o), n = q(s, s.FRAGMENT_SHADER, c, this.#f), f = fe(s, this.#d, n, this.#f);
+      return s.deleteShader(n), this.#c(e), f;
+    })();
+    return this.#T[t] = r, r;
+  }
+  async encodeTexture(t, r = {}) {
+    const e = this.#e;
+    typeof t == "string" && (t = await K(t)), this.#t(`Image type: ${t.constructor.name}`);
+    const s = t.width || t.videoWidth, o = t.height || t.videoHeight;
+    O(s && o);
+    const c = r.format ?? "rgb";
+    let n;
+    if (typeof c == "string") {
+      if (n = this.#b(c, r.preferLowQuality), n === void 0)
+        throw new Error(`Unsupported format: ${c}`);
+    } else if (n = c, !this.#l.has(n))
+      throw new Error(`Format not supported: ${v[n]}`);
+    const f = await this.#x(n);
+    this.#t(`Selected format: ${v[n]}`);
+    const u = Le[n], l = (r.srgb || r.format?.endsWith("srgb")) && De[n], h = Oe[n], m = h ? l ? h[1] : h[0] : null, R = Ve[n];
+    this.#t(`Using ${l ? "sRGB" : "linear"} color space`);
+    const T = `encodeTexture #${++this.#g}`;
+    this.#o(T);
+    const d = {
+      program: e.getParameter(e.CURRENT_PROGRAM),
+      activeTexture: e.getParameter(e.ACTIVE_TEXTURE),
+      textureBinding: e.getParameter(e.TEXTURE_BINDING_2D),
+      framebuffer: e.getParameter(e.FRAMEBUFFER_BINDING),
+      readFramebuffer: e.getParameter(e.READ_FRAMEBUFFER_BINDING),
+      viewport: e.getParameter(e.VIEWPORT),
+      blend: e.getParameter(e.BLEND),
+      depthTest: e.getParameter(e.DEPTH_TEST),
+      stencilTest: e.getParameter(e.STENCIL_TEST),
+      cullFace: e.getParameter(e.CULL_FACE),
+      scissorTest: e.getParameter(e.SCISSOR_TEST),
+      pixelPackBuffer: e.getParameter(e.PIXEL_PACK_BUFFER_BINDING),
+      pixelUnpackBuffer: e.getParameter(e.PIXEL_UNPACK_BUFFER_BINDING),
+      arrayBuffer: e.getParameter(e.ARRAY_BUFFER_BINDING),
+      vertexArray: e.getParameter(e.VERTEX_ARRAY_BINDING)
+    };
+    e.activeTexture(e.TEXTURE0), e.disable(e.BLEND), e.disable(e.DEPTH_TEST), e.disable(e.STENCIL_TEST), e.disable(e.CULL_FACE), e.disable(e.SCISSOR_TEST);
+    const V = r.wrap || "repeat";
+    let x;
+    switch (V) {
+      case "repeat":
+        x = e.REPEAT;
+        break;
+      case "mirror":
+        x = e.MIRRORED_REPEAT;
+        break;
+      case "clamp":
+      default:
+        x = e.CLAMP_TO_EDGE;
+        break;
+    }
+    const y = r.generateMipmaps || r.mips;
+    let S = 1;
+    if (y) {
+      let w = s, I = o;
+      for (; w > 4 || I > 4; )
+        S++, w = Math.max(1, Math.floor(w / 2)), I = Math.max(1, Math.floor(I / 2));
+    }
+    const _ = e.createTexture();
+    e.bindTexture(e.TEXTURE_2D, _), e.texParameteri(e.TEXTURE_2D, e.TEXTURE_MIN_FILTER, e.NEAREST), e.texParameteri(e.TEXTURE_2D, e.TEXTURE_MAG_FILTER, e.NEAREST), e.texParameteri(e.TEXTURE_2D, e.TEXTURE_WRAP_S, x), e.texParameteri(e.TEXTURE_2D, e.TEXTURE_WRAP_T, x), e.texParameteri(e.TEXTURE_2D, e.TEXTURE_MAX_LEVEL, 0), e.texImage2D(e.TEXTURE_2D, 0, e.RGBA8, s, o, 0, e.RGBA, e.UNSIGNED_BYTE, t);
+    let E = _;
+    if (r.flipY) {
+      this.#t("Flipping texture vertically");
+      const G = e.createTexture();
+      e.bindTexture(e.TEXTURE_2D, G), e.texParameteri(e.TEXTURE_2D, e.TEXTURE_MIN_FILTER, e.NEAREST), e.texParameteri(e.TEXTURE_2D, e.TEXTURE_MAG_FILTER, e.NEAREST), e.texParameteri(e.TEXTURE_2D, e.TEXTURE_WRAP_S, x), e.texParameteri(e.TEXTURE_2D, e.TEXTURE_WRAP_T, x), e.texStorage2D(e.TEXTURE_2D, 1, e.RGBA8, s, o);
+      const w = e.createFramebuffer();
+      e.bindFramebuffer(e.FRAMEBUFFER, w), e.framebufferTexture2D(e.FRAMEBUFFER, e.COLOR_ATTACHMENT0, e.TEXTURE_2D, G, 0), this.#d || (this.#d = q(e, e.VERTEX_SHADER, Y, this.#f));
+      const I = `#version 300 es
+        precision mediump float;
+        uniform sampler2D uTexture;
+        uniform ivec2 uTextureSize;
+        out vec4 fragColor;
+        void main() {
+          ivec2 coord = ivec2(gl_FragCoord.xy);
+          // Flip Y coordinate
+          coord.y = uTextureSize.y - 1 - coord.y;
+          fragColor = texelFetch(uTexture, coord, 0);
+        }`, F = e.createShader(e.VERTEX_SHADER);
+      e.shaderSource(F, Y), e.compileShader(F);
+      const M = e.createShader(e.FRAGMENT_SHADER);
+      e.shaderSource(M, I), e.compileShader(M);
+      const D = fe(e, F, M, this.#f);
+      e.useProgram(D), e.viewport(0, 0, s, o), e.activeTexture(e.TEXTURE0), e.bindTexture(e.TEXTURE_2D, _), e.uniform1i(e.getUniformLocation(D, "uTexture"), 0), e.uniform2i(e.getUniformLocation(D, "uTextureSize"), s, o), e.drawArrays(e.TRIANGLES, 0, 3), e.deleteShader(F), e.deleteShader(M), e.deleteProgram(D), e.deleteFramebuffer(w), e.deleteTexture(_), E = G;
+    }
+    y && (e.bindTexture(e.TEXTURE_2D, E), e.texParameteri(e.TEXTURE_2D, e.TEXTURE_MIN_FILTER, e.LINEAR_MIPMAP_LINEAR), e.texParameteri(e.TEXTURE_2D, e.TEXTURE_MAX_LEVEL, S - 1), e.generateMipmap(e.TEXTURE_2D), this.#t(`Generated ${S} mipmap levels`));
+    const P = e.createTexture();
+    e.bindTexture(e.TEXTURE_2D, P), e.texStorage2D(e.TEXTURE_2D, S, m, s, o), y ? (e.texParameteri(e.TEXTURE_2D, e.TEXTURE_MIN_FILTER, e.LINEAR_MIPMAP_LINEAR), e.texParameteri(e.TEXTURE_2D, e.TEXTURE_MAG_FILTER, e.LINEAR)) : (e.texParameteri(e.TEXTURE_2D, e.TEXTURE_MIN_FILTER, e.LINEAR), e.texParameteri(e.TEXTURE_2D, e.TEXTURE_MAG_FILTER, e.LINEAR)), e.texParameteri(e.TEXTURE_2D, e.TEXTURE_WRAP_S, x), e.texParameteri(e.TEXTURE_2D, e.TEXTURE_WRAP_T, x);
+    const Q = Math.ceil(s / 4), W = Math.ceil(o / 4), C = u * Q * W;
+    let k = C;
+    const b = this.#p;
+    let U;
+    b && this.#a && this.#E >= C ? U = this.#a : (b && this.#a && e.deleteBuffer(this.#a), U = e.createBuffer(), b && (this.#a = U, this.#E = C)), e.bindBuffer(e.PIXEL_PACK_BUFFER, U), e.bindBuffer(e.PIXEL_UNPACK_BUFFER, U), e.bufferData(e.PIXEL_PACK_BUFFER, C, e.STREAM_COPY);
+    let B;
+    const g = !b || this.#n < s || this.#_ < o;
+    u === 8 ? b && this.#s && !g ? B = this.#s : (b && this.#s && e.deleteTexture(this.#s), B = e.createTexture(), e.bindTexture(e.TEXTURE_2D, B), e.texStorage2D(e.TEXTURE_2D, 1, R, s, o), b && (this.#s = B, this.#n = s, this.#_ = o)) : b && this.#i && !g ? B = this.#i : (b && this.#i && e.deleteTexture(this.#i), B = e.createTexture(), e.bindTexture(e.TEXTURE_2D, B), e.texStorage2D(e.TEXTURE_2D, 1, R, s, o), b && (this.#i = B, this.#n = s, this.#_ = o));
+    let L;
+    b && this.#u ? L = this.#u : (L = e.createFramebuffer(), b && (this.#u = L)), e.bindFramebuffer(e.FRAMEBUFFER, L), e.readBuffer(e.COLOR_ATTACHMENT0), e.framebufferTexture2D(e.FRAMEBUFFER, e.COLOR_ATTACHMENT0, e.TEXTURE_2D, B, 0), e.useProgram(f);
+    for (let G = 0; G < S; G++) {
+      const w = Math.max(1, Math.floor(s >> G)), I = Math.max(1, Math.floor(o >> G)), F = Math.ceil(w / 4), M = Math.ceil(I / 4), D = u * F * M;
+      k += D, e.bindTexture(e.TEXTURE_2D, E), e.texParameteri(e.TEXTURE_2D, e.TEXTURE_BASE_LEVEL, G), e.texParameteri(e.TEXTURE_2D, e.TEXTURE_MAX_LEVEL, G), e.viewport(0, 0, F, M), e.drawArrays(e.TRIANGLES, 0, 3), e.readPixels(0, 0, F, M, e.RGBA_INTEGER, u === 16 ? e.UNSIGNED_INT : e.UNSIGNED_SHORT, 0), e.bindTexture(e.TEXTURE_2D, P), e.compressedTexSubImage2D(e.TEXTURE_2D, G, 0, 0, w, I, m, D, 0);
+    }
+    return b || (e.deleteTexture(B), e.deleteBuffer(U), e.deleteFramebuffer(L)), e.deleteTexture(E), e.bindFramebuffer(e.FRAMEBUFFER, d.framebuffer), e.bindFramebuffer(e.READ_FRAMEBUFFER, d.readFramebuffer), e.bindTexture(e.TEXTURE_2D, d.textureBinding), e.useProgram(d.program), e.activeTexture(d.activeTexture), e.viewport(d.viewport[0], d.viewport[1], d.viewport[2], d.viewport[3]), e.bindBuffer(e.PIXEL_PACK_BUFFER, d.pixelPackBuffer), e.bindBuffer(e.PIXEL_UNPACK_BUFFER, d.pixelUnpackBuffer), d.blend ? e.enable(e.BLEND) : e.disable(e.BLEND), d.depthTest ? e.enable(e.DEPTH_TEST) : e.disable(e.DEPTH_TEST), d.stencilTest ? e.enable(e.STENCIL_TEST) : e.disable(e.STENCIL_TEST), d.cullFace ? e.enable(e.CULL_FACE) : e.disable(e.CULL_FACE), d.scissorTest ? e.enable(e.SCISSOR_TEST) : e.disable(e.SCISSOR_TEST), e.bindBuffer(e.ARRAY_BUFFER, d.arrayBuffer), e.bindVertexArray(d.vertexArray), this.#c(T), {
+      texture: P,
+      width: s,
+      height: o,
+      format: m,
+      sparkFormat: n,
+      sparkFormatName: v[n],
+      srgb: l,
+      mipmapCount: S,
+      byteLength: k
+    };
   }
 }
 export {
-  D as Spark
+  me as Spark,
+  de as SparkGL
 };