@aethervtt/shard-texture 0.0.1

package/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2026 Patrick Dias
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

package/README.md

@@ -0,0 +1,3 @@
+# @aethervtt/shard-texture
+
+Part of [Shard](https://github.com/aethervtt/shard), a WebGPU-first 2D/3D game engine in TypeScript. See the repository for documentation.

package/dist/array.d.ts

@@ -0,0 +1,21 @@
+import type { Image } from './image.js';
+import { type TextureUsage } from './mips.js';
+/** What a `*.texarray.json` file holds. */
+export interface TextureArrayFile {
+    /** Image files (relative to the file), one per layer, in layer order. */
+    layers: string[];
+    /** Side of every layer in pixels (default: the first image's width, as a power of two). */
+    size?: number;
+    /** color (sRGB albedo), data (linear masks such as ORM), or normal. Default: from the file name. */
+    usage?: TextureUsage;
+    /** Normal maps: opengl (+Y up, the default) or directx (green flipped on import). */
+    normalMap?: 'opengl' | 'directx';
+}
+/** Bilinear resample to `width` × `height` (RGBA). */
+export declare function resizeImage(image: Image, width: number, height: number): Image;
+/**
+ * `*.texarray.json`: a 2D texture array from a list of images, all resized to one size, each with
+ * its own mip chain, stored as one uncompressed KTX2 (spec 0043). Materials bind it as
+ * `texture_2d_array`; terrain biomes index its layers. Editing any listed image re-imports it.
+ */
+export declare const TextureArrayImporter: import("@aethervtt/shard-assets").ImporterDef;

package/dist/array.js

@@ -0,0 +1,111 @@
+import { defineImporter } from "@aethervtt/shard-assets";
+import { defineSchema, ShardError } from "@aethervtt/shard-core";
+import { decodeImage } from "./decode/index.js";
+import { flipGreen, usageFromName } from "./importer.js";
+import { writeKtx2 } from "./ktx2.js";
+import { buildMips } from "./mips.js";
+function resizeImage(image, width, height) {
+  if (image.width === width && image.height === height) return image;
+  const src = image.data;
+  const out = image.kind === "u8" ? new Uint8Array(width * height * 4) : new Float32Array(width * height * 4);
+  for (let y = 0; y < height; y++) {
+    const fy = Math.min(image.height - 1, Math.max(0, (y + 0.5) * image.height / height - 0.5));
+    const y0 = Math.floor(fy);
+    const y1 = Math.min(image.height - 1, y0 + 1);
+    const ty = fy - y0;
+    for (let x = 0; x < width; x++) {
+      const fx = Math.min(image.width - 1, Math.max(0, (x + 0.5) * image.width / width - 0.5));
+      const x0 = Math.floor(fx);
+      const x1 = Math.min(image.width - 1, x0 + 1);
+      const tx = fx - x0;
+      for (let c = 0; c < 4; c++) {
+        const a = src[(y0 * image.width + x0) * 4 + c];
+        const b = src[(y0 * image.width + x1) * 4 + c];
+        const d = src[(y1 * image.width + x0) * 4 + c];
+        const e = src[(y1 * image.width + x1) * 4 + c];
+        const v = (a * (1 - tx) + b * tx) * (1 - ty) + (d * (1 - tx) + e * tx) * ty;
+        out[(y * width + x) * 4 + c] = image.kind === "u8" ? Math.round(v) : v;
+      }
+    }
+  }
+  return { width, height, kind: image.kind, data: out };
+}
+const NoSettings = defineSchema(
+  "texture/TextureArraySettings",
+  {},
+  { description: "None: the file lists the layers." }
+);
+function fail(path, message, hint) {
+  throw new ShardError("texture/invalid-array", `${path}: ${message}`, { path, hint });
+}
+const TextureArrayImporter = defineImporter({
+  name: "texture-array",
+  version: 1,
+  extensions: [".texarray.json"],
+  settings: NoSettings,
+  async import(source, ctx) {
+    let file;
+    try {
+      file = JSON.parse(source.text());
+    } catch (cause) {
+      throw new ShardError("assets/import-failed", `${source.path} isn't valid JSON`, {
+        path: source.path,
+        cause
+      });
+    }
+    const hint = 'A texture array file is { "layers": ["grass.png", "rock.png"], "size": 512, "usage": "color" }.';
+    if (!Array.isArray(file.layers) || file.layers.length === 0)
+      fail(source.path, '"layers" must list at least one image', hint);
+    if (file.layers.length > 256) fail(source.path, "at most 256 layers", hint);
+    const usage = file.usage ?? usageFromName(source.path.replace(".texarray.json", ""));
+    if (usage === "hdr") fail(source.path, "HDR arrays come later", "Use color, data, or normal.");
+    const images = [];
+    for (const layer of file.layers) {
+      let image = await decodeImage(await ctx.read(layer));
+      if (usage === "normal" && file.normalMap === "directx") image = flipGreen(image);
+      images.push(image);
+    }
+    const first = images[0];
+    let size = file.size ?? 2 ** Math.round(Math.log2(Math.max(1, first.width)));
+    size = Math.max(1, Math.min(4096, Math.floor(size)));
+    const chains = images.map((image, i) => {
+      if (image.width !== size || image.height !== size) {
+        ctx.warn(
+          `Layer ${i} (${file.layers[i]}) is ${image.width}\xD7${image.height}; resized to ${size}\xD7${size}.`
+        );
+      }
+      return buildMips(resizeImage(image, size, size), {
+        usage,
+        mipmaps: true,
+        maxSize: 16384,
+        flipY: false,
+        premultiplyAlpha: false
+      });
+    });
+    const levels = chains[0].levels.map((_, level) => {
+      const parts = chains.map((c) => c.levels[level]);
+      const out = new Uint8Array(parts.reduce((n, p) => n + p.byteLength, 0));
+      let o = 0;
+      for (const p of parts) {
+        out.set(p, o);
+        o += p.byteLength;
+      }
+      return out;
+    });
+    const bytes = writeKtx2({ width: size, height: size, levels }, usage, 1, false, images.length);
+    return {
+      assets: [
+        {
+          label: "",
+          type: "Texture",
+          bytes,
+          info: { width: size, height: size, layers: images.length, usage, mips: levels.length }
+        }
+      ]
+    };
+  }
+});
+export {
+  TextureArrayImporter,
+  resizeImage
+};

package/dist/basis.d.ts

@@ -0,0 +1,16 @@
+import type { TextureUsage } from './mips.js';
+/**
+ * Encodes RGBA8 into a Basis Universal KTX2 with a full mip chain. Dimensions must be multiples of
+ * 4 (the importer pads first). `mode`: 'uastc' (high quality) or 'etc1s' (small).
+ */
+export declare function encodeBasis(rgba: Uint8Array, width: number, height: number, usage: TextureUsage, mode: 'uastc' | 'etc1s', mipmaps: boolean): Promise<Uint8Array>;
+/** GPU formats a Basis texture can become, by device feature, best first. */
+export type TranscodeTarget = 'bc7' | 'bc5' | 'astc' | 'etc2' | 'eac-rg11' | 'rgba8';
+export interface TranscodedTexture {
+    width: number;
+    height: number;
+    format: TranscodeTarget;
+    levels: Uint8Array[];
+}
+/** Transcodes every level of a Basis KTX2 to `target`. */
+export declare function transcodeBasis(bytes: Uint8Array, target: TranscodeTarget): Promise<TranscodedTexture>;

package/dist/basis.js

@@ -0,0 +1,122 @@
+import { ShardError } from "@aethervtt/shard-core";
+const modules = /* @__PURE__ */ new Map();
+async function readVendor(file) {
+  const url = new URL(`../vendor/basis/${file}`, import.meta.url);
+  if (url.protocol === "file:") {
+    const { readFile } = await import("node:fs/promises");
+    const data = await readFile(url);
+    return file.endsWith(".js") ? { text: data.toString("utf8") } : { bytes: new Uint8Array(data) };
+  }
+  const res = await fetch(url);
+  if (!res.ok) throw new ShardError("texture/transcoder-unavailable", `Couldn't fetch ${url}`);
+  return file.endsWith(".js") ? { text: await res.text() } : { bytes: new Uint8Array(await res.arrayBuffer()) };
+}
+function load(name) {
+  let pending = modules.get(name);
+  if (!pending) {
+    pending = (async () => {
+      try {
+        const [{ text }, { bytes }] = await Promise.all([
+          readVendor(`${name}.js`),
+          readVendor(`${name}.wasm`)
+        ]);
+        let require2;
+        let dirname = "";
+        if (typeof process !== "undefined" && process.versions?.node) {
+          const { createRequire } = await import("node:module");
+          const { fileURLToPath } = await import("node:url");
+          require2 = createRequire(import.meta.url);
+          dirname = fileURLToPath(new URL("../vendor/basis/", import.meta.url));
+        }
+        const factory = new Function(
+          "module",
+          "exports",
+          "require",
+          "__dirname",
+          "__filename",
+          `${text}
+return BASIS`
+        )(void 0, void 0, require2, dirname, `${dirname}${name}.js`);
+        const quiet = () => {
+        };
+        const mod = await factory({ wasmBinary: bytes, print: quiet, printErr: quiet });
+        mod.initializeBasis();
+        return mod;
+      } catch (cause) {
+        throw new ShardError(
+          "texture/transcoder-unavailable",
+          `Couldn't load ${name}: ${cause.message}`,
+          {
+            cause,
+            hint: "Basis Universal ships in @aethervtt/shard-texture/vendor/basis; check the files are present."
+          }
+        );
+      }
+    })();
+    modules.set(name, pending);
+  }
+  return pending;
+}
+async function encodeBasis(rgba, width, height, usage, mode, mipmaps) {
+  const basis = await load("basis_encoder");
+  const enc = new basis.BasisEncoder();
+  try {
+    enc.setCreateKTX2File(true);
+    const format = mode === "uastc" ? basis.basis_tex_format.cUASTC_LDR_4x4 : basis.basis_tex_format.cETC1S;
+    enc.setFormatModeAndQualityEffort(format.value, -1, -1, true);
+    enc.setKTX2UASTCSupercompression(mode === "uastc");
+    const color = usage === "color";
+    enc.setPerceptual(color);
+    enc.setKTX2AndBasisSRGBTransferFunc(color);
+    enc.setMipGen(mipmaps);
+    enc.setMipSRGB(color);
+    enc.setMipRenormalize(usage === "normal");
+    enc.setCheckForAlpha(true);
+    if (!enc.setSliceSourceImage(0, rgba, width, height, 0)) {
+      throw new ShardError("texture/decode-failed", "Basis encoder rejected the image");
+    }
+    const out = new Uint8Array(width * height * 4 * 2 + 1024 * 1024);
+    const size = enc.encode(out);
+    if (!size) throw new ShardError("texture/decode-failed", "Basis encoding failed");
+    return out.slice(0, size);
+  } finally {
+    enc.delete();
+  }
+}
+const TARGET_FORMATS = {
+  bc7: "cTFBC7_RGBA",
+  bc5: "cTFBC5_RG",
+  astc: "cTFASTC_4x4_RGBA",
+  etc2: "cTFETC2_RGBA",
+  "eac-rg11": "cTFETC2_EAC_RG11",
+  rgba8: "cTFRGBA32"
+};
+async function transcodeBasis(bytes, target) {
+  const basis = await load("basis_transcoder");
+  const file = new basis.KTX2File(bytes);
+  try {
+    if (!file.isValid() || !file.startTranscoding()) {
+      throw new ShardError("texture/decode-failed", "Invalid Basis KTX2 payload");
+    }
+    const format = basis.transcoder_texture_format[TARGET_FORMATS[target]].value;
+    const levels = [];
+    for (let level = 0; level < file.getLevels(); level++) {
+      const dst = new Uint8Array(file.getImageTranscodedSizeInBytes(level, 0, 0, format));
+      if (!file.transcodeImage(dst, level, 0, 0, format, 0, -1, -1)) {
+        throw new ShardError(
+          "texture/decode-failed",
+          `Couldn't transcode level ${level} to ${target}`
+        );
+      }
+      levels.push(dst);
+    }
+    return { width: file.getWidth(), height: file.getHeight(), format: target, levels };
+  } finally {
+    file.close();
+    file.delete();
+  }
+}
+export {
+  encodeBasis,
+  transcodeBasis
+};

package/dist/decode/hdr.d.ts

@@ -0,0 +1,3 @@
+import type { Image } from '../image.js';
+/** Radiance RGBE (.hdr), flat or new-style run-length encoded, into linear RGBA floats. */
+export declare function decodeHdr(bytes: Uint8Array): Image;

package/dist/decode/hdr.js

@@ -0,0 +1,68 @@
+import { ShardError } from "@aethervtt/shard-core";
+function decodeHdr(bytes) {
+  const text = new TextDecoder("latin1");
+  let pos = 0;
+  const line = () => {
+    const start = pos;
+    while (pos < bytes.length && bytes[pos] !== 10) pos++;
+    return text.decode(bytes.subarray(start, pos++));
+  };
+  const magic = line();
+  if (!magic.startsWith("#?"))
+    throw new ShardError("texture/decode-failed", "Not a Radiance .hdr file");
+  for (let l = line(); l !== ""; l = line()) {
+    if (l.startsWith("FORMAT=") && l !== "FORMAT=32-bit_rle_rgbe") {
+      throw new ShardError(
+        "texture/unsupported-format",
+        `.hdr ${l} isn't supported (need 32-bit_rle_rgbe)`
+      );
+    }
+    if (pos >= bytes.length) throw new ShardError("texture/decode-failed", ".hdr header never ends");
+  }
+  const size = /^-Y (\d+) \+X (\d+)$/.exec(line());
+  if (!size)
+    throw new ShardError(
+      "texture/unsupported-format",
+      'Only "-Y h +X w" .hdr orientation is supported'
+    );
+  const height = Number(size[1]);
+  const width = Number(size[2]);
+  const rgbe = new Uint8Array(width * height * 4);
+  const scan = new Uint8Array(width * 4);
+  for (let y = 0; y < height; y++) {
+    const rle = width >= 8 && width < 32768 && bytes[pos] === 2 && bytes[pos + 1] === 2 && !(bytes[pos + 2] & 128);
+    if (!rle) {
+      rgbe.set(bytes.subarray(pos, pos + width * 4), y * width * 4);
+      pos += width * 4;
+      continue;
+    }
+    pos += 4;
+    for (let c = 0; c < 4; c++) {
+      let x = 0;
+      while (x < width) {
+        let count = bytes[pos++];
+        if (count > 128) {
+          count -= 128;
+          const v = bytes[pos++];
+          for (let k = 0; k < count; k++) scan[x++ * 4 + c] = v;
+        } else {
+          for (let k = 0; k < count; k++) scan[x++ * 4 + c] = bytes[pos++];
+        }
+      }
+    }
+    rgbe.set(scan, y * width * 4);
+  }
+  const out = new Float32Array(width * height * 4);
+  for (let i = 0; i < width * height; i++) {
+    const e = rgbe[i * 4 + 3];
+    const f = e === 0 ? 0 : 2 ** (e - 136);
+    out[i * 4] = rgbe[i * 4] * f;
+    out[i * 4 + 1] = rgbe[i * 4 + 1] * f;
+    out[i * 4 + 2] = rgbe[i * 4 + 2] * f;
+    out[i * 4 + 3] = 1;
+  }
+  return { width, height, kind: "f32", data: out };
+}
+export {
+  decodeHdr
+};

package/dist/decode/index.d.ts

@@ -0,0 +1,11 @@
+import type { Image } from '../image.js';
+import { decodeHdr } from './hdr.js';
+import { decodeJpeg } from './jpeg.js';
+import { decodePngImage } from './png.js';
+import { decodeWebp } from './webp.js';
+export type ImageFormat = 'png' | 'jpeg' | 'webp' | 'hdr' | 'ktx2';
+/** The file format, from its first bytes. */
+export declare function sniffImage(bytes: Uint8Array): ImageFormat | undefined;
+/** Decodes PNG, JPEG, WebP, or Radiance HDR with the engine's own decoders (never the browser's). */
+export declare function decodeImage(bytes: Uint8Array): Promise<Image>;
+export { decodeHdr, decodeJpeg, decodePngImage, decodeWebp };

package/dist/decode/index.js

@@ -0,0 +1,40 @@
+import { ShardError } from "@aethervtt/shard-core";
+import { decodeHdr } from "./hdr.js";
+import { decodeJpeg } from "./jpeg.js";
+import { decodePngImage } from "./png.js";
+import { decodeWebp } from "./webp.js";
+function sniffImage(bytes) {
+  const b = bytes;
+  if (b[0] === 137 && b[1] === 80 && b[2] === 78 && b[3] === 71) return "png";
+  if (b[0] === 255 && b[1] === 216) return "jpeg";
+  if (b[0] === 82 && b[1] === 73 && b[2] === 70 && b[3] === 70 && b[8] === 87 && b[9] === 69) {
+    return "webp";
+  }
+  if (b[0] === 35 && b[1] === 63) return "hdr";
+  if (b[0] === 171 && b[1] === 75 && b[2] === 84 && b[3] === 88) return "ktx2";
+  return void 0;
+}
+async function decodeImage(bytes) {
+  switch (sniffImage(bytes)) {
+    case "png":
+      return decodePngImage(bytes);
+    case "jpeg":
+      return decodeJpeg(bytes);
+    case "webp":
+      return decodeWebp(bytes);
+    case "hdr":
+      return decodeHdr(bytes);
+    default:
+      throw new ShardError("texture/unsupported-format", "Unrecognized image format", {
+        hint: "Supported: PNG, JPEG, WebP, Radiance .hdr, and KTX2."
+      });
+  }
+}
+export {
+  decodeHdr,
+  decodeImage,
+  decodeJpeg,
+  decodePngImage,
+  decodeWebp,
+  sniffImage
+};

package/dist/decode/jpeg.d.ts

@@ -0,0 +1,3 @@
+import type { Image } from '../image.js';
+/** Baseline and progressive JPEG, in pure JS (the same pixels on every host). */
+export declare function decodeJpeg(bytes: Uint8Array): Image;

package/dist/decode/jpeg.js

@@ -0,0 +1,21 @@
+import { ShardError } from "@aethervtt/shard-core";
+import jpeg from "jpeg-js";
+function decodeJpeg(bytes) {
+  try {
+    const out = jpeg.decode(bytes, {
+      useTArray: true,
+      formatAsRGBA: true,
+      maxMemoryUsageInMB: 1024
+    });
+    return { width: out.width, height: out.height, kind: "u8", data: out.data };
+  } catch (cause) {
+    throw new ShardError(
+      "texture/decode-failed",
+      `JPEG decode failed: ${cause.message}`,
+      { cause }
+    );
+  }
+}
+export {
+  decodeJpeg
+};

package/dist/decode/png.d.ts

@@ -0,0 +1,10 @@
+import type { Image } from '../image.js';
+export interface PngInfo {
+    /** The file declares sRGB (sRGB chunk or an ICC profile), linear (gAMA 1.0), or says nothing. */
+    colorSpace: 'srgb' | 'linear' | 'unspecified';
+}
+/**
+ * Decodes any standard PNG: gray, RGB, palette (with tRNS), gray+alpha, RGBA; bit depths 1–16;
+ * interlaced or not. Output is RGBA8 (16-bit samples round to 8 bits).
+ */
+export declare function decodePngImage(png: Uint8Array): Promise<Image & PngInfo>;

package/dist/decode/png.js

@@ -0,0 +1,193 @@
+import { ShardError } from "@aethervtt/shard-core";
+async function inflate(input) {
+  const stream = new Blob([input]).stream().pipeThrough(new DecompressionStream("deflate"));
+  return new Uint8Array(await new Response(stream).arrayBuffer());
+}
+const CHANNELS = { 0: 1, 2: 3, 3: 1, 4: 2, 6: 4 };
+const ADAM7 = [
+  [0, 0, 8, 8],
+  [4, 0, 8, 8],
+  [0, 4, 4, 8],
+  [2, 0, 4, 4],
+  [0, 2, 2, 4],
+  [1, 0, 2, 2],
+  [0, 1, 1, 2]
+];
+function paeth(a, b, c) {
+  const p = a + b - c;
+  const pa = Math.abs(p - a);
+  const pb = Math.abs(p - b);
+  const pc = Math.abs(p - c);
+  return pa <= pb && pa <= pc ? a : pb <= pc ? b : c;
+}
+function unfilter(raw, offset, rowBytes, rows, bpp) {
+  const out = new Uint8Array(rowBytes * rows);
+  for (let y = 0; y < rows; y++) {
+    const filter = raw[offset + y * (rowBytes + 1)];
+    const src = offset + y * (rowBytes + 1) + 1;
+    const row = y * rowBytes;
+    const prev = row - rowBytes;
+    for (let x = 0; x < rowBytes; x++) {
+      const v = raw[src + x];
+      const a = x >= bpp ? out[row + x - bpp] : 0;
+      const b = y > 0 ? out[prev + x] : 0;
+      const c = x >= bpp && y > 0 ? out[prev + x - bpp] : 0;
+      let r;
+      switch (filter) {
+        case 0:
+          r = v;
+          break;
+        case 1:
+          r = v + a;
+          break;
+        case 2:
+          r = v + b;
+          break;
+        case 3:
+          r = v + (a + b >> 1);
+          break;
+        case 4:
+          r = v + paeth(a, b, c);
+          break;
+        default:
+          throw new ShardError("texture/decode-failed", `PNG row filter ${filter} is invalid`);
+      }
+      out[row + x] = r & 255;
+    }
+  }
+  return out;
+}
+async function decodePngImage(png) {
+  const view = new DataView(png.buffer, png.byteOffset, png.byteLength);
+  if (png.length < 8 || view.getUint32(0) !== 2303741511) {
+    throw new ShardError("texture/decode-failed", "Not a PNG file");
+  }
+  let offset = 8;
+  let width = 0;
+  let height = 0;
+  let depth = 8;
+  let colorType = 6;
+  let interlace = 0;
+  let palette;
+  let trns;
+  let colorSpace = "unspecified";
+  const idat = [];
+  while (offset + 8 <= png.length) {
+    const length = view.getUint32(offset);
+    const type = String.fromCharCode(
+      png[offset + 4],
+      png[offset + 5],
+      png[offset + 6],
+      png[offset + 7]
+    );
+    const data = png.subarray(offset + 8, offset + 8 + length);
+    if (type === "IHDR") {
+      const d = new DataView(data.buffer, data.byteOffset);
+      width = d.getUint32(0);
+      height = d.getUint32(4);
+      depth = data[8];
+      colorType = data[9];
+      interlace = data[12];
+    } else if (type === "PLTE") palette = data;
+    else if (type === "tRNS") trns = data;
+    else if (type === "IDAT") idat.push(data);
+    else if (type === "sRGB" || type === "iCCP") colorSpace = "srgb";
+    else if (type === "gAMA" && colorSpace === "unspecified") {
+      const gamma = new DataView(data.buffer, data.byteOffset).getUint32(0);
+      colorSpace = gamma === 1e5 ? "linear" : "srgb";
+    } else if (type === "IEND") break;
+    offset += 12 + length;
+  }
+  const channels = CHANNELS[colorType];
+  if (!width || !height || !channels) {
+    throw new ShardError("texture/decode-failed", "PNG header is missing or invalid");
+  }
+  const joined = new Uint8Array(idat.reduce((n, p) => n + p.length, 0));
+  let o = 0;
+  for (const p of idat) {
+    joined.set(p, o);
+    o += p.length;
+  }
+  const raw = await inflate(joined);
+  const bitsPerPixel = channels * depth;
+  const bpp = Math.max(1, bitsPerPixel >> 3);
+  const out = new Uint8Array(width * height * 4);
+  const maxValue = (1 << depth) - 1;
+  const sample = (row, rowStart, x, c) => {
+    if (depth === 8) return row[rowStart + x * channels + c];
+    if (depth === 16) {
+      const i = rowStart + (x * channels + c) * 2;
+      return row[i] * 256 + row[i + 1];
+    }
+    const bit = (x * channels + c) * depth;
+    const byte = row[rowStart + (bit >> 3)];
+    return byte >> 8 - depth - (bit & 7) & maxValue;
+  };
+  const to8 = (v) => depth === 8 ? v : depth === 16 ? Math.round(v / 257) : Math.round(v * 255 / maxValue);
+  const put = (row, rowStart, x, px, py) => {
+    const i = (py * width + px) * 4;
+    if (colorType === 3) {
+      const index = sample(row, rowStart, x, 0);
+      out[i] = palette?.[index * 3] ?? 0;
+      out[i + 1] = palette?.[index * 3 + 1] ?? 0;
+      out[i + 2] = palette?.[index * 3 + 2] ?? 0;
+      out[i + 3] = trns && index < trns.length ? trns[index] : 255;
+      return;
+    }
+    if (colorType === 0 || colorType === 4) {
+      const g2 = sample(row, rowStart, x, 0);
+      out[i] = out[i + 1] = out[i + 2] = to8(g2);
+      if (colorType === 4) out[i + 3] = to8(sample(row, rowStart, x, 1));
+      else {
+        const key = trns ? new DataView(trns.buffer, trns.byteOffset).getUint16(0) : -1;
+        out[i + 3] = g2 === key ? 0 : 255;
+      }
+      return;
+    }
+    const r = sample(row, rowStart, x, 0);
+    const g = sample(row, rowStart, x, 1);
+    const b = sample(row, rowStart, x, 2);
+    out[i] = to8(r);
+    out[i + 1] = to8(g);
+    out[i + 2] = to8(b);
+    if (colorType === 6) out[i + 3] = to8(sample(row, rowStart, x, 3));
+    else {
+      const t = trns ? new DataView(trns.buffer, trns.byteOffset) : void 0;
+      out[i + 3] = t && r === t.getUint16(0) && g === t.getUint16(2) && b === t.getUint16(4) ? 0 : 255;
+    }
+  };
+  if (interlace === 0) {
+    const rowBytes = Math.ceil(width * bitsPerPixel / 8);
+    const pixels = unfilter(raw, 0, rowBytes, height, bpp);
+    if (depth === 8 && colorType === 6)
+      return { width, height, kind: "u8", data: pixels, colorSpace };
+    if (depth === 8 && colorType === 2 && !trns) {
+      for (let i = 0, o2 = 0; i < pixels.length; i += 3, o2 += 4) {
+        out[o2] = pixels[i];
+        out[o2 + 1] = pixels[i + 1];
+        out[o2 + 2] = pixels[i + 2];
+        out[o2 + 3] = 255;
+      }
+      return { width, height, kind: "u8", data: out, colorSpace };
+    }
+    for (let y = 0; y < height; y++)
+      for (let x = 0; x < width; x++) put(pixels, y * rowBytes, x, x, y);
+  } else {
+    let at = 0;
+    for (const [sx, sy, dx, dy] of ADAM7) {
+      const w = Math.ceil((width - sx) / dx);
+      const h = Math.ceil((height - sy) / dy);
+      if (w <= 0 || h <= 0) continue;
+      const rowBytes = Math.ceil(w * bitsPerPixel / 8);
+      const pixels = unfilter(raw, at, rowBytes, h, bpp);
+      at += (rowBytes + 1) * h;
+      for (let y = 0; y < h; y++) {
+        for (let x = 0; x < w; x++) put(pixels, y * rowBytes, x, sx + x * dx, sy + y * dy);
+      }
+    }
+  }
+  return { width, height, kind: "u8", data: out, colorSpace };
+}
+export {
+  decodePngImage
+};

package/dist/decode/webp.d.ts

@@ -0,0 +1,2 @@
+import type { Image } from '../image.js';
+export declare function decodeWebp(bytes: Uint8Array): Promise<Image>;