@ludicon/spark.js 0.0.11 → 0.0.13

package/dist/spark.esm.js

@@ -1,12 +1,6 @@
-const modules = /* @__PURE__ */ Object.assign({ "./spark_astc_rgb.wgsl": () => import("./spark_astc_rgb-ylbf30mQ.js"), "./spark_astc_rgba.wgsl": () => import("./spark_astc_rgba-C4NuyfHw.js"), "./spark_bc1_rgb.wgsl": () => import("./spark_bc1_rgb-L0ZV40FW.js"), "./spark_bc4_r.wgsl": () => import("./spark_bc4_r-B4cqoXVq.js"), "./spark_bc5_rg.wgsl": () => import("./spark_bc5_rg-boGe-kBy.js"), "./spark_bc7_rgb.wgsl": () => import("./spark_bc7_rgb-CYdL55pE.js"), "./spark_bc7_rgba.wgsl": () => import("./spark_bc7_rgba-BFgOyqos.js"), "./spark_eac_r.wgsl": () => import("./spark_eac_r-BFwH430b.js"), "./spark_eac_rg.wgsl": () => import("./spark_eac_rg--Gm5Gzmk.js"), "./spark_etc2_rgb.wgsl": () => import("./spark_etc2_rgb-CWjBHhHQ.js"), "./utils.wgsl": () => import("./utils-CqE_M33R.js") });
-const shaders = Object.fromEntries(
-  Object.entries(modules).map(([path, module]) => {
-    const name = path.replace("./", "");
-    const fn = async () => (await module()).default;
-    return [name, fn];
-  })
-);
-const SparkFormat = {
+const z = /* @__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-Dw9jXlhw.js") }), k = Object.fromEntries(
+  Object.entries(z).map(([n, e]) => [n.replace("./", ""), async () => (await e()).default])
+), s = {
   ASTC_4x4_RGB: 0,
   ASTC_4x4_RGBA: 1,
   // ASTC_4x4_RGBM: 2,
@@ -25,8 +19,7 @@ const SparkFormat = {
   // BC6H_RGB: 15,
   BC7_RGB: 16,
   BC7_RGBA: 17
-};
-const SparkFormatName = [
+}, B = [
   /* 0  */
   "astc-4x4-rgb",
   // ASTC_4x4_RGB
@@ -73,8 +66,7 @@ const SparkFormatName = [
   /* 17 */
   "bc7-rgba"
   // BC7_RGBA
-];
-const SparkShaderFiles = [
+], q = [
   /* 0  */
   "spark_astc_rgb.wgsl",
   // ASTC_4x4_RGB
@@ -121,8 +113,7 @@ const SparkShaderFiles = [
   /* 17 */
   "spark_bc7_rgba.wgsl"
   // BC7_RGBA
-];
-const SparkBlockSize = [
+], Y = [
   /* 0  */
   16,
   // ASTC_4x4_RGB
@@ -169,8 +160,7 @@ const SparkBlockSize = [
   /* 17 */
   16
   // BC7_RGB
-];
-const SparkFormatRatio = [
+], W = [
   /* 0  */
   4,
   // ASTC_4x4_RGB
@@ -217,36 +207,34 @@ const SparkFormatRatio = [
   /* 17 */
   4
   // BC7_RGB
-];
-const SparkFormatMap = Object.freeze({
-  "astc-4x4-rgb": SparkFormat.ASTC_4x4_RGB,
-  "astc-4x4-rgba": SparkFormat.ASTC_4x4_RGBA,
-  "eac-r": SparkFormat.EAC_R,
-  "eac-rg": SparkFormat.EAC_RG,
-  "etc2-rgb": SparkFormat.ETC2_RGB,
-  "bc1-rgb": SparkFormat.BC1_RGB,
-  "bc4-r": SparkFormat.BC4_R,
-  "bc5-rg": SparkFormat.BC5_RG,
-  "bc7-rgb": SparkFormat.BC7_RGB,
-  "bc7-rgba": SparkFormat.BC7_RGBA,
+], T = Object.freeze({
+  "astc-4x4-rgb": s.ASTC_4x4_RGB,
+  "astc-4x4-rgba": s.ASTC_4x4_RGBA,
+  "eac-r": s.EAC_R,
+  "eac-rg": s.EAC_RG,
+  "etc2-rgb": s.ETC2_RGB,
+  "bc1-rgb": s.BC1_RGB,
+  "bc4-r": s.BC4_R,
+  "bc5-rg": s.BC5_RG,
+  "bc7-rgb": s.BC7_RGB,
+  "bc7-rgba": s.BC7_RGBA,
   // aliases:
-  "astc-rgb": SparkFormat.ASTC_4x4_RGB,
-  "astc-rgba": SparkFormat.ASTC_4x4_RGBA,
+  "astc-rgb": s.ASTC_4x4_RGB,
+  "astc-rgba": s.ASTC_4x4_RGBA,
   // webgpu aliases:
-  "bc1-rgba-unorm": SparkFormat.BC1_RGB,
-  "bc1-rgba-unorm-srgb": SparkFormat.BC1_RGB,
-  "bc4-r-unorm": SparkFormat.BC4_R,
-  "bc5-rg-unorm": SparkFormat.BC5_RG,
-  "bc7-rgba-unorm": SparkFormat.BC7_RGBA,
-  "bc7-rgba-unorm-srgb": SparkFormat.BC7_RGBA,
-  "etc2-rgb8unorm": SparkFormat.ETC2_RGB,
-  "etc2-rgb8unorm-srgb": SparkFormat.ETC2_RGB,
-  "eac-r11unorm": SparkFormat.EAC_R,
-  "eac-rg11unorm": SparkFormat.EAC_RG,
-  "astc-4x4-unorm": SparkFormat.ASTC_4x4_RGBA,
-  "astc-4x4-unorm-srgb": SparkFormat.ASTC_4x4_RGBA
-});
-const SparkWebGPUFormats = [
+  "bc1-rgba-unorm": s.BC1_RGB,
+  "bc1-rgba-unorm-srgb": s.BC1_RGB,
+  "bc4-r-unorm": s.BC4_R,
+  "bc5-rg-unorm": s.BC5_RG,
+  "bc7-rgba-unorm": s.BC7_RGBA,
+  "bc7-rgba-unorm-srgb": s.BC7_RGBA,
+  "etc2-rgb8unorm": s.ETC2_RGB,
+  "etc2-rgb8unorm-srgb": s.ETC2_RGB,
+  "eac-r11unorm": s.EAC_R,
+  "eac-rg11unorm": s.EAC_RG,
+  "astc-4x4-unorm": s.ASTC_4x4_RGBA,
+  "astc-4x4-unorm-srgb": s.ASTC_4x4_RGBA
+}), V = [
   /* 0  */
   "astc-4x4-unorm",
   // ASTC_4x4_RGB
@@ -293,33 +281,32 @@ const SparkWebGPUFormats = [
   /* 17 */
   "bc7-rgba-unorm"
   // BC7_RGB
-];
-const SparkFormatIsRGB = [
+], $ = [
   /* 0  */
-  true,
+  !0,
   // ASTC_4x4_RGB
   /* 1  */
-  true,
+  !0,
   // ASTC_4x4_RGBA
   /* 2  */
   null,
   /* 3  */
   null,
   /* 4  */
-  false,
+  !1,
   // EAC_R
   /* 5  */
-  false,
+  !1,
   // EAC_RG
   /* 6  */
-  true,
+  !0,
   // ETC2_RGB
   /* 7  */
   null,
   /* 8  */
   null,
   /* 9  */
-  true,
+  !0,
   // BC1_RGB
   /* 10 */
   null,
@@ -328,135 +315,113 @@ const SparkFormatIsRGB = [
   /* 12 */
   null,
   /* 13 */
-  false,
+  !1,
   // BC4_R
   /* 14 */
-  false,
+  !1,
   // BC5_RG
   /* 15 */
   null,
   /* 16 */
-  true,
+  !0,
   // BC7_RGB
   /* 17 */
-  true
+  !0
   // BC7_RGB
 ];
-function assert(condition, message) {
-  if (!condition) {
-    throw new Error(message);
-  }
+function w(n, e) {
+  if (!n)
+    throw new Error(e);
 }
-function isWebGPU(device) {
-  return typeof GPUDevice != "undefined" && device instanceof GPUDevice;
+function X(n) {
+  return typeof GPUDevice < "u" && n instanceof GPUDevice;
 }
-function isIOS() {
+function F() {
   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 getSafariVersion() {
-  const match = navigator.userAgent.match(/Safari\/(\d+(\.\d+)?)/);
-  return match && parseFloat(match[1]);
+function j() {
+  const n = navigator.userAgent.match(/Safari\/(\d+(\.\d+)?)/);
+  return n && parseFloat(n[1]);
 }
-function getFirefoxVersion() {
-  const match = navigator.userAgent.match(/Firefox\/(\d+(\.\d+)?)/);
-  return match && parseFloat(match[1]);
+function Q() {
+  const n = navigator.userAgent.match(/Firefox\/(\d+(\.\d+)?)/);
+  return n && parseFloat(n[1]);
 }
-function detectWebGPUFormats(device) {
-  const supportedFormats = /* @__PURE__ */ new Set();
-  const formatMap = {
+function H(n) {
+  const e = /* @__PURE__ */ new Set(), r = {
     "texture-compression-bc": [
-      SparkFormat.BC1_RGB,
-      SparkFormat.BC4_R,
-      SparkFormat.BC5_RG,
-      SparkFormat.BC7_RGB,
-      SparkFormat.BC7_RGBA
+      s.BC1_RGB,
+      s.BC4_R,
+      s.BC5_RG,
+      s.BC7_RGB,
+      s.BC7_RGBA
     ],
-    "texture-compression-etc2": [SparkFormat.ETC2_RGB, SparkFormat.EAC_R, SparkFormat.EAC_RG],
-    "texture-compression-astc": [SparkFormat.ASTC_4x4_RGB, SparkFormat.ASTC_4x4_RGBA]
+    "texture-compression-etc2": [s.ETC2_RGB, s.EAC_R, s.EAC_RG],
+    "texture-compression-astc": [s.ASTC_4x4_RGB, s.ASTC_4x4_RGBA]
   };
-  for (const [feature, formats] of Object.entries(formatMap)) {
-    if (device.features.has(feature)) {
-      for (const format of formats) {
-        supportedFormats.add(format);
-      }
-    }
-  }
-  return supportedFormats;
+  for (const [t, i] of Object.entries(r))
+    if (n.features.has(t))
+      for (const a of i)
+        e.add(a);
+  return e;
 }
-function imageToByteArray(image) {
-  const canvas = document.createElement("canvas");
-  canvas.width = image.width;
-  canvas.height = image.height;
-  const ctx = canvas.getContext("2d");
-  ctx.drawImage(image, 0, 0);
-  const imageData = ctx.getImageData(0, 0, image.width, image.height);
-  return new Uint8Array(imageData.data.buffer);
+function Z(n) {
+  const e = document.createElement("canvas");
+  e.width = n.width, e.height = n.height;
+  const r = e.getContext("2d");
+  r.drawImage(n, 0, 0);
+  const t = r.getImageData(0, 0, n.width, n.height);
+  return new Uint8Array(t.data.buffer);
 }
-function isSvgUrl(url) {
-  return /\.svg(?:$|\?)/i.test(url) || /^data:image\/svg\+xml[,;]/i.test(url);
+function J(n) {
+  return /\.svg(?:$|\?)/i.test(n) || /^data:image\/svg\+xml[,;]/i.test(n);
 }
-function loadImageElement(url) {
-  return new Promise((resolve, reject) => {
-    const img = new Image();
-    img.crossOrigin = "anonymous";
-    img.decoding = "async";
-    img.onload = () => resolve(img);
-    img.onerror = reject;
-    img.src = url;
+function K(n) {
+  return new Promise((e, r) => {
+    const t = new Image();
+    t.crossOrigin = "anonymous", t.decoding = "async", t.onload = () => e(t), t.onerror = r, t.src = n;
   });
 }
-async function loadImageBitmap(url, opts = {}) {
-  const res = await fetch(url, { mode: "cors" });
-  if (!res.ok) throw new Error(`HTTP ${res.status} for ${url}`);
-  const blob = await res.blob();
-  return createImageBitmap(blob, {
-    imageOrientation: opts.flipY ? "flipY" : "none",
-    colorSpaceConversion: opts.colorSpaceConversion ?? "none",
+async function ee(n, e = {}) {
+  const r = await fetch(n, { mode: "cors" });
+  if (!r.ok) throw new Error(`HTTP ${r.status} for ${n}`);
+  const t = await r.blob();
+  return createImageBitmap(t, {
+    imageOrientation: e.flipY ? "flipY" : "none",
+    colorSpaceConversion: e.colorSpaceConversion ?? "none",
     premultiplyAlpha: "none"
   });
 }
-function loadImage(url) {
-  if (isSvgUrl(url)) {
-    return loadImageElement(url);
-  } else {
-    return loadImageBitmap(url);
-  }
+const te = F();
+function v(n) {
+  return J(n) || te ? K(n) : ee(n);
 }
-const BYTES_PER_ROW_ALIGNMENT = 256;
-const MIN_MIP_SIZE = 4;
-function computeMipmapLayout(w, h, blockSize, mipmaps) {
-  let mipmapCount = 0;
-  let offset = 0;
-  const bufferRanges = [];
+const O = 256, N = 4;
+function re(n, e, r, t) {
+  let i = 0, a = 0;
+  const o = [];
   do {
-    const bw = Math.ceil(w / 4);
-    const bh = Math.ceil(h / 4);
-    const bytesPerRow = Math.ceil(bw * blockSize / BYTES_PER_ROW_ALIGNMENT) * BYTES_PER_ROW_ALIGNMENT;
-    const alignedSize = bh * bytesPerRow;
-    mipmapCount++;
-    bufferRanges.push({ offset, alignedSize, w, h, bw, bh, bytesPerRow });
-    offset += alignedSize;
-    w = Math.max(1, Math.floor(w / 2));
-    h = Math.max(1, Math.floor(h / 2));
-  } while (mipmaps && (w >= MIN_MIP_SIZE || h >= MIN_MIP_SIZE));
-  return { mipmapCount, outputSize: offset, bufferRanges };
+    const c = Math.ceil(n / 4), u = Math.ceil(e / 4), f = Math.ceil(c * r / O) * O, l = u * f;
+    i++, o.push({ offset: a, alignedSize: l, w: n, h: e, bw: c, bh: u, bytesPerRow: f }), a += l, n = Math.max(1, Math.floor(n / 2)), e = Math.max(1, Math.floor(e / 2));
+  } while (t && (n >= N || e >= N));
+  return { mipmapCount: i, outputSize: a, bufferRanges: o };
 }
-class Spark {
-  #device;
-  #supportedFormats;
-  #pipelines = [];
-  #supportsFloat16;
-  #mipmapPipeline;
-  #resizePipeline;
-  #flipYPipeline;
-  #detectChannelCountPipeline;
-  #defaultSampler;
-  #uniformBuffer = new Array(3);
-  #querySet;
-  #queryBuffer;
-  #queryReadbackBuffer;
-  #encodeCounter = 0;
+class L {
+  #e;
+  #o;
+  #i = [];
+  #l;
+  #c;
+  #m;
+  #g;
+  #u;
+  #a;
+  #n = new Array(3);
+  #r;
+  #f;
+  #s;
+  #_ = 0;
   /**
    * Initialize the encoder by detecting available compression formats.
    * @param {GPUDevice} device - WebGPU device.
@@ -464,10 +429,9 @@ class Spark {
    * @param {boolean} options.preload - Whether to preload all encoder pipelines (false by default).
    * @returns {Promise<void>} Resolves when initialization is complete.
    */
-  static async create(device, options = {}) {
-    const instance = new Spark();
-    await instance.#init(device, options.preload ?? false, options.useTimestampQueries ?? false);
-    return instance;
+  static async create(e, r = {}) {
+    const t = new L();
+    return await t.#B(e, r.preload ?? !1, r.useTimestampQueries ?? !1), t;
   }
   /**
    * Returns a list of supported texture compression format names.
@@ -484,7 +448,7 @@ class Spark {
    * console.log("Supported formats:", formats);
    */
   enumerateSupportedFormats() {
-    const formats = [
+    const e = [
       "astc-4x4-rgb",
       "astc-4x4-rgba",
       "eac-r",
@@ -495,16 +459,15 @@ class Spark {
       "bc5-rg",
       "bc7-rgb",
       "bc7-rgba"
-    ];
-    const supported = [];
-    for (const format of formats) {
-      const sparkFormat = SparkFormatMap[format];
-      if (this.#isFormatSupported(sparkFormat)) {
-        const ratio = SparkFormatRatio[sparkFormat];
-        supported.push({ format, ratio });
+    ], r = [];
+    for (const t of e) {
+      const i = T[t];
+      if (this.#t(i)) {
+        const a = W[i];
+        r.push({ format: t, ratio: a });
       }
     }
-    return supported;
+    return r;
   }
   /**
    * Determines the set of WebGPU features to request when initializing the device.
@@ -524,25 +487,9 @@ class Spark {
    * // Create spark object for the given device.
    * const spark = Spark.create(device)
    */
-  static getRequiredFeatures(adapter) {
-    const features = [];
-    const IOS = isIOS();
-    if (!IOS && adapter.features.has("texture-compression-bc")) {
-      features.push("texture-compression-bc");
-    }
-    if (adapter.features.has("texture-compression-etc2")) {
-      features.push("texture-compression-etc2");
-    }
-    if (adapter.features.has("texture-compression-astc")) {
-      features.push("texture-compression-astc");
-    }
-    if (adapter.features.has("shader-f16")) {
-      features.push("shader-f16");
-    }
-    if (adapter.features.has("timestamp-query")) {
-      features.push("timestamp-query");
-    }
-    return features;
+  static getRequiredFeatures(e) {
+    const r = [];
+    return !F() && 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;
   }
   /**
    * Try to determine the best compression options automatically. Do not use this in production, this is
@@ -552,20 +499,14 @@ class Spark {
    * @param {Object} options - Encoding options.
    * @returns {Object} - Recommended encoding options with an explicit encoding format.
    */
-  async selectPreferredOptions(source, options = {}) {
-    if (options.format == void 0 || options.format == "auto") {
-      const image = source instanceof Image || source instanceof ImageBitmap || source instanceof GPUTexture ? source : await loadImage(source);
-      options.format = "auto";
-      const format = await this.#getBestMatchingFormat(options, image);
-      options.format = SparkFormatName[format];
-      if (image instanceof GPUTexture) {
-        if (image.format.endsWith("-srgb")) options.srgb = true;
-      }
-      if (format == SparkFormat.EAC_RG || format == SparkFormat.BC5_RG) {
-        options.normal = true;
-      }
+  async selectPreferredOptions(e, r = {}) {
+    if (r.format == null || r.format == "auto") {
+      const t = e instanceof Image || e instanceof ImageBitmap || e instanceof GPUTexture ? e : await v(e);
+      r.format = "auto";
+      const i = await this.#b(r, t);
+      r.format = B[i], t instanceof GPUTexture && t.format.endsWith("-srgb") && (r.srgb = !0), (i == s.EAC_RG || i == s.BC5_RG) && (r.normal = !0);
     }
-    return options;
+    return r;
   }
   /**
    * Load an image and encode it to a compressed GPU texture.
@@ -606,183 +547,105 @@ class Spark {
    *
    * @returns {Promise<GPUTexture>} A promise resolving to the encoded GPU texture.
    */
-  async encodeTexture(source, options = {}) {
-    assert(this.#device, "Spark is not initialized");
-    const image = source instanceof Image || source instanceof ImageBitmap || source instanceof GPUTexture ? source : await loadImage(source);
-    console.log("Loaded image", image);
-    const format = await this.#getBestMatchingFormat(options, image);
-    const pipelinePromise = this.#loadPipeline(format);
-    const width = Math.ceil(image.width / 4) * 4;
-    const height = Math.ceil(image.height / 4) * 4;
-    const blockSize = SparkBlockSize[format];
-    const mipmaps = options.generateMipmaps || options.mips;
-    const { mipmapCount, outputSize, bufferRanges } = computeMipmapLayout(width, height, blockSize, mipmaps);
-    const srgb = (options.srgb || options.format?.endsWith("srgb")) && SparkFormatIsRGB[format];
-    const colorMode = srgb ? 1 : options.normal ? 2 : 0;
-    const webgpuFormat = SparkWebGPUFormats[format] + (srgb ? "-srgb" : "");
-    const viewFormats = srgb ? ["rgba8unorm", "rgba8unorm-srgb"] : ["rgba8unorm"];
-    const counter = this.#encodeCounter++;
-    console.time("create input texture #" + counter);
-    let inputUsage = GPUTextureUsage.TEXTURE_BINDING | GPUTextureUsage.COPY_DST | GPUTextureUsage.STORAGE_BINDING;
-    const needsProcessing = options.flipY || width != image.width || height != image.height;
-    if (!needsProcessing && !(image instanceof GPUTexture)) {
-      inputUsage |= GPUTextureUsage.RENDER_ATTACHMENT;
-    }
-    const commandEncoder = this.#device.createCommandEncoder();
-    commandEncoder.pushDebugGroup?.("spark process texture");
-    if (this.#querySet && typeof commandEncoder.writeTimestamp === "function") {
-      commandEncoder.writeTimestamp(this.#querySet, 0);
-    }
-    let inputTexture;
-    if (needsProcessing || !(image instanceof GPUTexture && !mipmaps)) {
-      inputTexture = this.#device.createTexture({
-        size: [width, height, 1],
-        mipLevelCount: mipmapCount,
-        format: "rgba8unorm",
-        usage: inputUsage,
-        viewFormats
-      });
-    }
-    let tmpTexture;
-    if (needsProcessing) {
-      if (image instanceof GPUTexture) {
-        this.#processInputTexture(commandEncoder, image, inputTexture, width, height, srgb, options.flipY);
-      } else {
-        tmpTexture = this.#device.createTexture({
-          size: [image.width, image.height, 1],
-          mipLevelCount: 1,
-          format: "rgba8unorm",
-          // RENDER_ATTACHMENT usage is necessary for copyExternalImageToTexture
-          usage: GPUTextureUsage.TEXTURE_BINDING | GPUTextureUsage.COPY_DST | GPUTextureUsage.RENDER_ATTACHMENT,
-          viewFormats
-        });
-        this.#device.queue.copyExternalImageToTexture(
-          { source: image },
-          { texture: tmpTexture },
-          { width: image.width, height: image.height }
-        );
-        this.#processInputTexture(commandEncoder, tmpTexture, inputTexture, width, height, colorMode, options.flipY);
-      }
-    } else {
-      if (image instanceof GPUTexture) {
-        if (mipmaps) {
-          commandEncoder.copyTextureToTexture({ texture: image }, { texture: inputTexture }, { width, height });
-        } else {
-          inputTexture = image;
-        }
-      } else {
-        this.#device.queue.copyExternalImageToTexture({ source: image }, { texture: inputTexture }, { width, height });
-      }
-    }
-    if (mipmaps) {
-      this.#generateMipmaps(commandEncoder, inputTexture, mipmapCount, width, height, colorMode);
-    }
-    commandEncoder.popDebugGroup?.();
-    console.timeEnd("create input texture #" + counter);
-    const outputTexture = this.#device.createTexture({
-      size: [width, height, 1],
-      mipLevelCount: mipmapCount,
-      format: webgpuFormat,
+  async encodeTexture(e, r = {}) {
+    w(this.#e, "Spark is not initialized");
+    const t = e instanceof Image || e instanceof ImageBitmap || e instanceof GPUTexture ? e : await v(e);
+    console.log("Loaded image", t);
+    const i = await this.#b(r, t), a = this.#p(i), o = Math.ceil(t.width / 4) * 4, c = Math.ceil(t.height / 4) * 4, u = Y[i], f = r.generateMipmaps || r.mips, { mipmapCount: l, outputSize: d, bufferRanges: m } = re(o, c, u, f), h = (r.srgb || r.format?.endsWith("srgb")) && $[i], _ = h ? 1 : r.normal ? 2 : 0, G = V[i] + (h ? "-srgb" : ""), A = h ? ["rgba8unorm", "rgba8unorm-srgb"] : ["rgba8unorm"], x = this.#_++;
+    console.time("create input texture #" + x);
+    let S = GPUTextureUsage.TEXTURE_BINDING | GPUTextureUsage.COPY_DST | GPUTextureUsage.STORAGE_BINDING;
+    const P = r.flipY || o != t.width || c != t.height;
+    !P && !(t instanceof GPUTexture) && (S |= GPUTextureUsage.RENDER_ATTACHMENT);
+    const g = this.#e.createCommandEncoder();
+    g.pushDebugGroup?.("spark process texture"), this.#r && typeof g.writeTimestamp == "function" && g.writeTimestamp(this.#r, 0);
+    let b;
+    (P || !(t instanceof GPUTexture && !f)) && (b = this.#e.createTexture({
+      size: [o, c, 1],
+      mipLevelCount: l,
+      format: "rgba8unorm",
+      usage: S,
+      viewFormats: A
+    }));
+    let C;
+    P ? t instanceof GPUTexture ? this.#d(g, t, b, o, c, h, r.flipY) : (C = 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: C },
+      { width: t.width, height: t.height }
+    ), this.#d(g, C, b, o, c, _, r.flipY)) : t instanceof GPUTexture ? f ? g.copyTextureToTexture({ texture: t }, { texture: b }, { width: o, height: c }) : b = t : this.#e.queue.copyExternalImageToTexture({ source: t }, { texture: b }, { width: o, height: c }), f && this.#T(g, b, l, o, c, _), g.popDebugGroup?.(), console.timeEnd("create input texture #" + x);
+    const U = this.#e.createTexture({
+      size: [o, c, 1],
+      mipLevelCount: l,
+      format: G,
       usage: GPUTextureUsage.TEXTURE_BINDING | GPUTextureUsage.COPY_DST
-    });
-    const outputBuffer = this.#device.createBuffer({
-      size: outputSize,
+    }), y = this.#e.createBuffer({
+      size: d,
       usage: GPUBufferUsage.STORAGE | GPUBufferUsage.COPY_SRC
+    }), E = `dispatch compute shader '${B[i]}' #${x}`;
+    console.time(E), g.pushDebugGroup?.("spark encode texture");
+    let M = {};
+    this.#r && typeof g.writeTimestamp != "function" && (M = {
+      writeTimestamps: {
+        querySet: this.#r,
+        beginningOfPassWriteIndex: 0,
+        endOfPassWriteIndex: 1
+      }
     });
-    const label = `dispatch compute shader '${SparkFormatName[format]}' #${counter}`;
-    console.time(label);
-    commandEncoder.pushDebugGroup?.("spark encode texture");
-    let args = {};
-    if (this.#querySet && typeof commandEncoder.writeTimestamp !== "function") {
-      args = {
-        writeTimestamps: {
-          querySet: this.#querySet,
-          beginningOfPassWriteIndex: 0,
-          endOfPassWriteIndex: 1
-        }
-      };
-    }
-    const pipeline = await pipelinePromise;
-    const pass = commandEncoder.beginComputePass(args);
-    pass.setPipeline(pipeline);
-    for (let m = 0; m < mipmapCount; m++) {
-      const bindGroup = this.#device.createBindGroup({
-        layout: pipeline.getBindGroupLayout(0),
+    const I = await a, R = g.beginComputePass(M);
+    R.setPipeline(I);
+    for (let p = 0; p < l; p++) {
+      const D = this.#e.createBindGroup({
+        layout: I.getBindGroupLayout(0),
         entries: [
           {
             binding: 0,
-            resource: inputTexture.createView({
-              baseMipLevel: m,
+            resource: b.createView({
+              baseMipLevel: p,
               mipLevelCount: 1
             })
           },
           {
             binding: 1,
-            resource: this.#defaultSampler
+            resource: this.#a
           },
           {
             binding: 2,
             resource: {
-              buffer: outputBuffer,
-              offset: bufferRanges[m].offset,
-              size: bufferRanges[m].size
+              buffer: y,
+              offset: m[p].offset,
+              size: m[p].size
             }
           }
         ]
       });
-      pass.setBindGroup(0, bindGroup);
-      pass.dispatchWorkgroups(Math.ceil(bufferRanges[m].bw / 16), Math.ceil(bufferRanges[m].bh / 16));
+      R.setBindGroup(0, D), R.dispatchWorkgroups(Math.ceil(m[p].bw / 16), Math.ceil(m[p].bh / 16));
     }
-    pass.end();
-    for (let m = 0; m < mipmapCount; m++) {
-      commandEncoder.copyBufferToTexture(
+    R.end();
+    for (let p = 0; p < l; p++)
+      g.copyBufferToTexture(
         {
-          buffer: outputBuffer,
-          offset: bufferRanges[m].offset,
-          bytesPerRow: bufferRanges[m].bytesPerRow,
-          rowsPerImage: bufferRanges[m].bh
+          buffer: y,
+          offset: m[p].offset,
+          bytesPerRow: m[p].bytesPerRow,
+          rowsPerImage: m[p].bh
         },
         {
-          texture: outputTexture,
-          mipLevel: m
+          texture: U,
+          mipLevel: p
         },
         {
-          width: bufferRanges[m].bw * 4,
-          height: bufferRanges[m].bh * 4,
+          width: m[p].bw * 4,
+          height: m[p].bh * 4,
           depthOrArrayLayers: 1
         }
       );
-    }
-    if (this.#querySet && typeof commandEncoder.writeTimestamp === "function") {
-      commandEncoder.writeTimestamp(this.#querySet, 1);
-    }
-    commandEncoder.popDebugGroup?.();
-    this.#device.queue.submit([commandEncoder.finish()]);
-    console.timeEnd(label);
-    tmpTexture?.destroy();
-    if (inputTexture != image) {
-      inputTexture?.destroy();
-    }
-    outputBuffer?.destroy();
-    return outputTexture;
-  }
-  /**
-   * Returns the size of the given image after compression with the given options. This is an approximation
-   * as it doesn't take into account the specific GPU memory layout.
-   */
-  async estimateSize(image, options = {}) {
-    assert(this.#device, "Spark is not initialized");
-    assert(image instanceof Image || image instanceof ImageBitmap || image instanceof GPUTexture);
-    const format = this.#getPreferredFormat(options.format ?? "rgb", options.preferLowQuality);
-    if (format === void 0) {
-      throw new Error(`Unsupported format: ${options.format}`);
-    }
-    const width = Math.ceil(image.width / 4) * 4;
-    const height = Math.ceil(image.height / 4) * 4;
-    const blockSize = SparkBlockSize[format];
-    const mipmaps = options.generateMipmaps || options.mips;
-    const { outputSize } = computeMipmapLayout(width, height, blockSize, mipmaps);
-    return outputSize;
+    return this.#r && typeof g.writeTimestamp == "function" && g.writeTimestamp(this.#r, 1), g.popDebugGroup?.(), this.#e.queue.submit([g.finish()]), console.timeEnd(E), C?.destroy(), b != t && b?.destroy(), y?.destroy(), U;
   }
   /**
    * Returns the time (in milliseconds) it took to perform the most recent `encodeTexture()` call.
@@ -804,170 +667,128 @@ class Spark {
    * @throws {Error} If the GPU work has not been submitted, or if timestamp queries fail.
    */
   async getTimeElapsed() {
-    if (!this.#querySet) {
+    if (!this.#r)
       return 0;
-    }
-    const commandEncoder = this.#device.createCommandEncoder();
-    commandEncoder.resolveQuerySet(this.#querySet, 0, 2, this.#queryBuffer, 0);
-    commandEncoder.copyBufferToBuffer(this.#queryBuffer, 0, this.#queryReadbackBuffer, 0, 16);
-    this.#device.queue.submit([commandEncoder.finish()]);
-    await this.#device.queue.onSubmittedWorkDone();
-    await this.#queryReadbackBuffer.mapAsync(GPUMapMode.READ);
-    const arrayBuffer = this.#queryReadbackBuffer.getMappedRange();
-    const timestamps = new BigUint64Array(arrayBuffer);
-    const t0 = timestamps[0];
-    const t1 = timestamps[1];
-    this.#queryReadbackBuffer.unmap();
-    const elapsedNanoseconds = Number(t1 - t0);
-    const elapsedMilliseconds = elapsedNanoseconds / 1e6;
-    return elapsedMilliseconds;
+    const e = this.#e.createCommandEncoder();
+    e.resolveQuerySet(this.#r, 0, 2, this.#f, 0), e.copyBufferToBuffer(this.#f, 0, this.#s, 0, 16), this.#e.queue.submit([e.finish()]), await this.#e.queue.onSubmittedWorkDone(), await this.#s.mapAsync(GPUMapMode.READ);
+    const r = this.#s.getMappedRange(), t = new BigUint64Array(r), i = t[0], a = t[1];
+    return this.#s.unmap(), Number(a - i) / 1e6;
   }
-  async #init(device, preload, useTimestampQueries) {
-    assert(device, "device is required");
-    assert(isWebGPU(device), "device is not a WebGPU device");
-    this.#device = device;
-    this.#supportedFormats = detectWebGPUFormats(this.#device);
-    this.#defaultSampler = this.#device.createSampler({
+  async #B(e, r, t) {
+    w(e, "device is required"), w(X(e), "device is not a WebGPU device"), this.#e = e, this.#o = H(this.#e), this.#a = this.#e.createSampler({
       magFilter: "linear",
       minFilter: "linear"
     });
-    for (let i = 0; i < 3; i++) {
-      this.#uniformBuffer[i] = this.#device.createBuffer({
+    for (let i = 0; i < 3; i++)
+      this.#n[i] = this.#e.createBuffer({
         size: 4,
         usage: GPUBufferUsage.UNIFORM | GPUBufferUsage.COPY_DST
-      });
-      this.#device.queue.writeBuffer(this.#uniformBuffer[i], 0, new Uint32Array([i]));
+      }), this.#e.queue.writeBuffer(this.#n[i], 0, new Uint32Array([i]));
+    if (t && this.#e.features.has("timestamp-query")) {
+      const i = j(), a = Q();
+      (!i || i >= 26) && !a && (this.#r = this.#e.createQuerySet({
+        type: "timestamp",
+        count: 2
+      }), this.#f = this.#e.createBuffer({
+        size: 16,
+        // 2 timestamps × 8 bytes each
+        usage: GPUBufferUsage.COPY_SRC | GPUBufferUsage.QUERY_RESOLVE
+      }), this.#s = this.#e.createBuffer({
+        size: 16,
+        // 2 timestamps × 8 bytes each
+        usage: GPUBufferUsage.COPY_DST | GPUBufferUsage.MAP_READ
+      }));
     }
-    if (useTimestampQueries && this.#device.features.has("timestamp-query")) {
-      const webkitVersion = getSafariVersion();
-      const firefoxVersion = getFirefoxVersion();
-      if ((!webkitVersion || webkitVersion >= 26) && !firefoxVersion) {
-        this.#querySet = this.#device.createQuerySet({
-          type: "timestamp",
-          count: 2
-        });
-        this.#queryBuffer = this.#device.createBuffer({
-          size: 16,
-          // 2 timestamps × 8 bytes each
-          usage: GPUBufferUsage.COPY_SRC | GPUBufferUsage.QUERY_RESOLVE
+    if (this.#l = this.#e.features.has("shader-f16"), await this.#G(), r) {
+      let i;
+      Array.isArray(r) ? i = r.map((a) => this.#h(a, !1)) : i = this.#o;
+      for (const a of i)
+        a !== void 0 && !this.#i[a] && this.#p(a).catch((o) => {
+          console.error(`Failed to preload pipeline for format ${a}:`, o);
         });
-        this.#queryReadbackBuffer = this.#device.createBuffer({
-          size: 16,
-          // 2 timestamps × 8 bytes each
-          usage: GPUBufferUsage.COPY_DST | GPUBufferUsage.MAP_READ
-        });
-      }
-    }
-    this.#supportsFloat16 = this.#device.features.has("shader-f16");
-    await this.#loadUtilPipelines();
-    if (preload) {
-      let formatsToLoad;
-      if (Array.isArray(preload)) {
-        formatsToLoad = preload.map((n) => this.#getPreferredFormat(n, false));
-      } else {
-        formatsToLoad = this.#supportedFormats;
-      }
-      for (const format of formatsToLoad) {
-        if (format !== void 0 && !this.#pipelines[format]) {
-          this.#loadPipeline(format).catch((err) => {
-            console.error(`Failed to preload pipeline for format ${format}:`, err);
-          });
-        }
-      }
     }
   }
-  async #loadUtilPipelines() {
-    const shaderModule = this.#device.createShaderModule({
-      code: await shaders["utils.wgsl"](),
+  async #G() {
+    const e = this.#e.createShaderModule({
+      code: await k["utils.wgsl"](),
       label: "utils"
     });
-    if (typeof shaderModule.compilationInfo == "function") {
-      const info = await shaderModule.compilationInfo();
-      if (info.messages.some((msg) => msg.type == "error")) {
+    if (typeof e.compilationInfo == "function") {
+      const r = await e.compilationInfo();
+      if (r.messages.some((t) => t.type == "error")) {
         console.error("WGSL compilation errors:");
-        for (const msg of info.messages) {
-          console.error(msg);
-        }
+        for (const t of r.messages)
+          console.error(t);
         throw new Error("Shader compilation failed");
       }
     }
-    this.#mipmapPipeline = await this.#device.createComputePipelineAsync({
+    this.#c = await this.#e.createComputePipelineAsync({
       layout: "auto",
       compute: {
-        module: shaderModule,
+        module: e,
         entryPoint: "mipmap"
       }
-    });
-    this.#resizePipeline = await this.#device.createComputePipelineAsync({
+    }), this.#m = await this.#e.createComputePipelineAsync({
       layout: "auto",
       compute: {
-        module: shaderModule,
+        module: e,
         entryPoint: "resize"
       }
-    });
-    this.#flipYPipeline = await this.#device.createComputePipelineAsync({
+    }), this.#g = await this.#e.createComputePipelineAsync({
       layout: "auto",
       compute: {
-        module: shaderModule,
+        module: e,
         entryPoint: "flipy"
       }
-    });
-    this.#detectChannelCountPipeline = await this.#device.createComputePipelineAsync({
+    }), this.#u = await this.#e.createComputePipelineAsync({
       layout: "auto",
       compute: {
-        module: shaderModule,
+        module: e,
         entryPoint: "detect_channel_count"
       }
     });
   }
-  async #loadPipeline(format) {
-    if (this.#pipelines[format]) {
-      return this.#pipelines[format];
-    }
-    const pipelinePromise = (async () => {
-      console.time("loadPipeline " + SparkFormatName[format]);
-      const shaderFile = SparkShaderFiles[format];
-      assert(shaderFile, `No shader available for format ${SparkFormatName[format]}`);
-      let shaderCode = await shaders[shaderFile]();
-      if (!this.#supportsFloat16) {
-        shaderCode = shaderCode.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 shaderModule = this.#device.createShaderModule({
-        code: shaderCode,
-        label: SparkFormatName[format]
+  async #p(e) {
+    if (this.#i[e])
+      return this.#i[e];
+    const r = (async () => {
+      console.time("loadPipeline " + B[e]);
+      const t = q[e];
+      w(t, `No shader available for format ${B[e]}`);
+      let i = await k[t]();
+      this.#l || (i = i.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 a = this.#e.createShaderModule({
+        code: i,
+        label: B[e]
       });
-      if (typeof shaderModule.getCompilationInfo == "function") {
-        const info = await shaderModule.getCompilationInfo();
-        if (info.messages.some((msg) => msg.type == "error")) {
+      if (typeof a.getCompilationInfo == "function") {
+        const c = await a.getCompilationInfo();
+        if (c.messages.some((u) => u.type == "error")) {
           console.error("WGSL compilation errors:");
-          for (const msg of info.messages) {
-            console.error(msg);
-          }
+          for (const u of c.messages)
+            console.error(u);
           throw new Error("Shader compilation failed");
         }
       }
-      const pipeline = await this.#device.createComputePipelineAsync({
+      const o = await this.#e.createComputePipelineAsync({
         layout: "auto",
         compute: {
-          module: shaderModule,
+          module: a,
           entryPoint: "main"
         }
       });
-      console.timeEnd("loadPipeline " + SparkFormatName[format]);
-      return pipeline;
+      return console.timeEnd("loadPipeline " + B[e]), o;
     })();
-    this.#pipelines[format] = pipelinePromise;
-    return pipelinePromise;
+    return this.#i[e] = r, r;
   }
-  #isFormatSupported(format) {
-    return this.#supportedFormats.has(format);
+  #t(e) {
+    return this.#o.has(e);
   }
-  #getPreferredFormat(format, preferLowQuality) {
-    const explicitFormat = SparkFormatMap[format];
-    if (explicitFormat != void 0 && this.#isFormatSupported(explicitFormat)) {
-      return explicitFormat;
-    }
-    const preferenceOrder = preferLowQuality ? [
+  #h(e, r) {
+    const t = T[e];
+    if (t != null && this.#t(t))
+      return t;
+    const i = r ? [
       "bc4-r",
       "eac-r",
       "bc5-rg",
@@ -994,149 +815,106 @@ class Spark {
       "astc-rgba",
       "astc-4x4-rgba"
     ];
-    for (const key of preferenceOrder) {
-      if (key.includes(format) && this.#isFormatSupported(SparkFormatMap[key])) {
-        return SparkFormatMap[key];
-      }
-    }
+    for (const a of i)
+      if (a.includes(e) && this.#t(T[a]))
+        return T[a];
   }
-  async #getBestMatchingFormat(options, image) {
-    if (options.format == void 0) {
-      options.format = "rgb";
-    } else if (options.format == "auto") {
-      if (options.alpha) {
-        if (this.#isFormatSupported(SparkFormat.BC7_RGBA)) return SparkFormat.BC7_RGBA;
-        if (this.#isFormatSupported(SparkFormat.ASTC_4x4_RGBA)) return SparkFormat.ASTC_4x4_RGBA;
-      } else if (options.srgb) {
-        if (this.#isFormatSupported(SparkFormat.BC7_RGB)) return SparkFormat.BC7_RGB;
-        if (this.#isFormatSupported(SparkFormat.ASTC_4x4_RGB)) return SparkFormat.ASTC_4x4_RGB;
-        if (this.#isFormatSupported(SparkFormat.BC1_RGB)) return SparkFormat.BC1_RGB;
-        if (this.#isFormatSupported(SparkFormat.ETC2_RGB)) return SparkFormat.ETC2_RGB;
-      } else if (options.normal) {
-        if (this.#isFormatSupported(SparkFormat.BC5_RG)) return SparkFormat.BC5_RG;
-        if (this.#isFormatSupported(SparkFormat.EAC_RG)) return SparkFormat.EAC_RG;
+  async #b(e, r) {
+    if (e.format == null)
+      e.format = "rgb";
+    else if (e.format == "auto") {
+      if (e.alpha) {
+        if (this.#t(s.BC7_RGBA)) return s.BC7_RGBA;
+        if (this.#t(s.ASTC_4x4_RGBA)) return s.ASTC_4x4_RGBA;
+      } else if (e.srgb) {
+        if (this.#t(s.BC7_RGB)) return s.BC7_RGB;
+        if (this.#t(s.ASTC_4x4_RGB)) return s.ASTC_4x4_RGB;
+        if (this.#t(s.BC1_RGB)) return s.BC1_RGB;
+        if (this.#t(s.ETC2_RGB)) return s.ETC2_RGB;
+      } else if (e.normal) {
+        if (this.#t(s.BC5_RG)) return s.BC5_RG;
+        if (this.#t(s.EAC_RG)) return s.EAC_RG;
       } else {
-        let channelCount;
-        if (image instanceof GPUTexture) {
-          if (image.format == "r8unorm" || image.format == "r16unorm") channelCount = 1;
-          else if (image.format == "rg8unorm" || image.format == "rg16unorm") channelCount = 2;
-          else {
-            channelCount = await this.#detectChannelCountGPU(image);
-          }
-        } else {
-          const buffer = imageToByteArray(image);
-          channelCount = this.#detectChannelCount(buffer);
+        let i;
+        if (r instanceof GPUTexture)
+          r.format == "r8unorm" || r.format == "r16unorm" ? i = 1 : r.format == "rg8unorm" || r.format == "rg16unorm" ? i = 2 : i = await this.#R(r);
+        else {
+          const a = Z(r);
+          i = this.#C(a);
         }
-        if (channelCount == 4) {
-          if (this.#isFormatSupported(SparkFormat.BC7_RGBA)) return SparkFormat.BC7_RGBA;
-          if (this.#isFormatSupported(SparkFormat.ASTC_4x4_RGBA)) return SparkFormat.ASTC_4x4_RGBA;
-        } else if (channelCount == 3) {
-          if (this.#isFormatSupported(SparkFormat.BC7_RGB)) return SparkFormat.BC7_RGB;
-          if (this.#isFormatSupported(SparkFormat.ASTC_4x4_RGB)) return SparkFormat.ASTC_4x4_RGB;
-          if (this.#isFormatSupported(SparkFormat.BC1_RGB)) return SparkFormat.BC1_RGB;
-          if (this.#isFormatSupported(SparkFormat.ETC2_RGB)) return SparkFormat.ETC2_RGB;
-        } else if (channelCount == 2) {
-          if (this.#isFormatSupported(SparkFormat.BC5_RG)) return SparkFormat.BC5_RG;
-          if (this.#isFormatSupported(SparkFormat.EAC_RG)) return SparkFormat.EAC_RG;
-        } else if (channelCount == 1) {
-          if (this.#isFormatSupported(SparkFormat.BC4_R)) return SparkFormat.BC4_R;
-          if (this.#isFormatSupported(SparkFormat.EAC_R)) return SparkFormat.EAC_R;
+        if (i == 4) {
+          if (this.#t(s.BC7_RGBA)) return s.BC7_RGBA;
+          if (this.#t(s.ASTC_4x4_RGBA)) return s.ASTC_4x4_RGBA;
+        } else if (i == 3) {
+          if (this.#t(s.BC7_RGB)) return s.BC7_RGB;
+          if (this.#t(s.ASTC_4x4_RGB)) return s.ASTC_4x4_RGB;
+          if (this.#t(s.BC1_RGB)) return s.BC1_RGB;
+          if (this.#t(s.ETC2_RGB)) return s.ETC2_RGB;
+        } else if (i == 2) {
+          if (this.#t(s.BC5_RG)) return s.BC5_RG;
+          if (this.#t(s.EAC_RG)) return s.EAC_RG;
+        } else if (i == 1) {
+          if (this.#t(s.BC4_R)) return s.BC4_R;
+          if (this.#t(s.EAC_R)) return s.EAC_R;
         }
       }
       throw new Error("No supported format found.");
     }
-    const format = this.#getPreferredFormat(options.format, options.preferLowQuality);
-    if (format === void 0) {
-      throw new Error(`Unsupported format: ${options.format}`);
-    }
-    return format;
+    const t = this.#h(e.format, e.preferLowQuality);
+    if (t === void 0)
+      throw new Error(`Unsupported format: ${e.format}`);
+    return t;
   }
-  #detectChannelCount(imageData) {
-    let opaque = true;
-    let grayscale = true;
-    let invalidNormalCount = 0;
-    const count = Math.min(1024 * 128, imageData.length);
-    for (let i = 0; i < count; i += 4) {
-      const r = imageData[i] / 255;
-      const g = imageData[i + 1] / 255;
-      const b = imageData[i + 2] / 255;
-      const a = imageData[i + 3];
-      if (a < 255) opaque = false;
-      if (r != g || g != b) grayscale = false;
-      const x = 2 * r - 1;
-      const y = 2 * g - 1;
-      const z = 2 * b - 1;
-      const len2 = x * x + y * y + z * z;
-      const len = Math.sqrt(len2);
-      if (Math.abs(len - 1) > 0.2 || z < -0.1) invalidNormalCount += 1;
+  #C(e) {
+    let r = !0, t = !0, i = 0;
+    const a = Math.min(1024 * 128, e.length);
+    for (let o = 0; o < a; o += 4) {
+      const c = e[o] / 255, u = e[o + 1] / 255, f = e[o + 2] / 255;
+      e[o + 3] < 255 && (r = !1), (c != u || u != f) && (t = !1);
+      const d = 2 * c - 1, m = 2 * u - 1, h = 2 * f - 1, _ = d * d + m * m + h * h, G = Math.sqrt(_);
+      (Math.abs(G - 1) > 0.2 || h < -0.1) && (i += 1);
     }
-    if (!opaque) return 4;
-    if (grayscale) return 1;
-    if (4 * 4 * invalidNormalCount < count) return 2;
-    return 3;
+    return r ? t ? 1 : 16 * i < a ? 2 : 3 : 4;
   }
-  async #detectChannelCountGPU(texture) {
-    const counterSize = 12;
-    const counterBuffer = this.#device.createBuffer({
-      size: counterSize,
+  async #R(e) {
+    const t = this.#e.createBuffer({
+      size: 12,
       usage: GPUBufferUsage.STORAGE | GPUBufferUsage.COPY_SRC
-    });
-    const readbackBuffer = this.#device.createBuffer({
-      size: counterSize,
+    }), i = this.#e.createBuffer({
+      size: 12,
       usage: GPUBufferUsage.COPY_DST | GPUBufferUsage.MAP_READ
-    });
-    const bindGroup = this.#device.createBindGroup({
-      layout: this.#detectChannelCountPipeline.getBindGroupLayout(0),
+    }), a = this.#e.createBindGroup({
+      layout: this.#u.getBindGroupLayout(0),
       entries: [
-        { binding: 0, resource: texture.createView() },
-        { binding: 1, resource: { buffer: counterBuffer } }
+        { binding: 0, resource: e.createView() },
+        { binding: 1, resource: { buffer: t } }
       ]
-    });
-    const encoder = this.#device.createCommandEncoder();
-    const pass = encoder.beginComputePass();
-    pass.setPipeline(this.#detectChannelCountPipeline);
-    pass.setBindGroup(0, bindGroup);
-    const { width, height } = texture;
-    const dispatchX = Math.ceil(width / 8);
-    const dispatchY = Math.ceil(height / 8);
-    pass.dispatchWorkgroups(dispatchX, dispatchY);
-    pass.end();
-    encoder.copyBufferToBuffer(counterBuffer, 0, readbackBuffer, 0, counterSize);
-    this.#device.queue.submit([encoder.finish()]);
-    await this.#device.queue.onSubmittedWorkDone();
-    await readbackBuffer.mapAsync(GPUMapMode.READ);
-    const view = new Uint32Array(readbackBuffer.getMappedRange());
-    const opaque = view[0] == 0;
-    const grayscale = view[1] == 0;
-    const invalidNormalCount = view[2];
-    readbackBuffer.unmap();
-    readbackBuffer.destroy();
-    counterBuffer.destroy();
-    if (!opaque) return 4;
-    if (grayscale) return 1;
-    if (4 * invalidNormalCount < width * height) return 2;
-    return 3;
+    }), o = this.#e.createCommandEncoder(), c = o.beginComputePass();
+    c.setPipeline(this.#u), c.setBindGroup(0, a);
+    const { width: u, height: f } = e, l = Math.ceil(u / 8), d = Math.ceil(f / 8);
+    c.dispatchWorkgroups(l, d), c.end(), o.copyBufferToBuffer(t, 0, i, 0, 12), this.#e.queue.submit([o.finish()]), await this.#e.queue.onSubmittedWorkDone(), await i.mapAsync(GPUMapMode.READ);
+    const m = new Uint32Array(i.getMappedRange()), h = m[0] == 0, _ = m[1] == 0, G = m[2];
+    return i.unmap(), i.destroy(), t.destroy(), h ? _ ? 1 : 4 * G < u * f ? 2 : 3 : 4;
   }
   // Apply scaling and flipY transform.
-  async #processInputTexture(encoder, inputTexture, outputTexture, width, height, colorMode, flipY) {
-    const pass = encoder.beginComputePass();
-    const pipeline = flipY ? this.#flipYPipeline : this.#resizePipeline;
-    pass.setPipeline(pipeline);
-    const bindGroup = this.#device.createBindGroup({
-      layout: pipeline.getBindGroupLayout(0),
+  async #d(e, r, t, i, a, o, c) {
+    const u = e.beginComputePass(), f = c ? this.#g : this.#m;
+    u.setPipeline(f);
+    const l = this.#e.createBindGroup({
+      layout: f.getBindGroupLayout(0),
       entries: [
         {
           binding: 0,
-          resource: inputTexture.createView({
+          resource: r.createView({
             baseMipLevel: 0,
             mipLevelCount: 1,
-            format: colorMode == 1 ? "rgba8unorm-srgb" : "rgba8unorm",
+            format: o == 1 ? "rgba8unorm-srgb" : "rgba8unorm",
             usage: GPUTextureUsage.TEXTURE_BINDING
           })
         },
         {
           binding: 1,
-          resource: outputTexture.createView({
+          resource: t.createView({
             baseMipLevel: 0,
             mipLevelCount: 1,
             dimension: "2d",
@@ -1146,47 +924,41 @@ class Spark {
         },
         {
           binding: 2,
-          resource: this.#defaultSampler
+          resource: this.#a
         },
         {
           binding: 3,
-          resource: { buffer: this.#uniformBuffer[colorMode] }
+          resource: { buffer: this.#n[o] }
         }
       ]
     });
-    pass.setBindGroup(0, bindGroup);
-    pass.dispatchWorkgroups(Math.ceil(width / 8), Math.ceil(height / 8));
-    pass.end();
+    u.setBindGroup(0, l), u.dispatchWorkgroups(Math.ceil(i / 8), Math.ceil(a / 8)), u.end();
   }
-  async #generateMipmaps(encoder, texture, mipmapCount, width, height, colorMode) {
-    const pass = encoder.beginComputePass();
-    pass.setPipeline(this.#mipmapPipeline);
-    let w = width;
-    let h = height;
-    for (let i = 0; i < mipmapCount - 1; i++) {
-      w = Math.max(1, Math.floor(w / 2));
-      h = Math.max(1, Math.floor(h / 2));
-      this.#generateMipLevel(pass, texture, i, i + 1, w, h, colorMode);
-    }
-    pass.end();
+  async #T(e, r, t, i, a, o) {
+    const c = e.beginComputePass();
+    c.setPipeline(this.#c);
+    let u = i, f = a;
+    for (let l = 0; l < t - 1; l++)
+      u = Math.max(1, Math.floor(u / 2)), f = Math.max(1, Math.floor(f / 2)), this.#w(c, r, l, l + 1, u, f, o);
+    c.end();
   }
-  #generateMipLevel(pass, texture, srcLevel, dstLevel, width, height, colorMode) {
-    const bindGroup = this.#device.createBindGroup({
-      layout: this.#mipmapPipeline.getBindGroupLayout(0),
+  #w(e, r, t, i, a, o, c) {
+    const u = this.#e.createBindGroup({
+      layout: this.#c.getBindGroupLayout(0),
       entries: [
         {
           binding: 0,
-          resource: texture.createView({
-            baseMipLevel: srcLevel,
+          resource: r.createView({
+            baseMipLevel: t,
             mipLevelCount: 1,
-            format: colorMode == 1 ? "rgba8unorm-srgb" : "rgba8unorm",
+            format: c == 1 ? "rgba8unorm-srgb" : "rgba8unorm",
             usage: GPUTextureUsage.TEXTURE_BINDING
           })
         },
         {
           binding: 1,
-          resource: texture.createView({
-            baseMipLevel: dstLevel,
+          resource: r.createView({
+            baseMipLevel: i,
             mipLevelCount: 1,
             dimension: "2d",
             format: "rgba8unorm",
@@ -1195,18 +967,17 @@ class Spark {
         },
         {
           binding: 2,
-          resource: this.#defaultSampler
+          resource: this.#a
         },
         {
           binding: 3,
-          resource: { buffer: this.#uniformBuffer[colorMode] }
+          resource: { buffer: this.#n[c] }
         }
       ]
     });
-    pass.setBindGroup(0, bindGroup);
-    pass.dispatchWorkgroups(Math.ceil(width / 8), Math.ceil(height / 8));
+    e.setBindGroup(0, u), e.dispatchWorkgroups(Math.ceil(a / 8), Math.ceil(o / 8));
   }
 }
 export {
-  Spark
+  L as Spark
 };