@levischuck/tiny-png 0.0.8 → 0.2.0

package/dist/bytes.d.ts

@@ -1 +1 @@
-export declare function concat(...bytes: Uint8Array[]): Uint8Array;
+export declare function concat(...bytes: Uint8Array[]): Uint8Array<ArrayBuffer>;

package/dist/index.d.ts

@@ -1,5 +1,12 @@
+export { scanChunk, iterateChunks, findChunk, readIHDR, validatePngSignature, readPngIHDR, type PngChunk, type ColorType, type InterlaceMethod, type IHDRData, } from './reader.ts';
 /**
- * Generate an indexed-color PNG image, up to 255 colors are supported
+ * Generate an indexed-color PNG image, up to 256 colors are supported
+ *
+ * Automatically selects the optimal bit depth based on the number of colors used:
+ * - 1-bit for 2 or fewer colors
+ * - 2-bit for 4 or fewer colors
+ * - 4-bit for 16 or fewer colors
+ * - 8-bit for up to 256 colors
  *
  * @param input - Pixel data as a Uint8Array where each byte is a palette index
  * @param width - Image width in pixels
@@ -10,4 +17,4 @@
  * @throws Error if the input does not match the dimensions.
  * @throws Error if the input is empty.
  */
-export declare function indexedPng(input: Uint8Array, width: number, height: number, colors: [number, number, number][]): Promise<Uint8Array>;
+export declare function indexedPng(input: Uint8Array, width: number, height: number, colors: [number, number, number][]): Promise<Uint8Array<ArrayBuffer>>;

package/dist/index.js

@@ -1,79 +1,215 @@
-function x(...r) {
+function k(...t) {
   const e = new Uint8Array(
-    r.reduceRight((o, i) => o + i.length, 0)
+    t.reduceRight((r, o) => r + o.length, 0)
   );
-  let t = 0;
-  for (const o of r)
-    e.set(o, t), t += o.length;
+  let n = 0;
+  for (const r of t)
+    e.set(r, n), n += r.length;
   return e;
 }
-async function E(r) {
-  const e = new CompressionStream("deflate"), t = e.writable.getWriter();
-  t.write(r), t.close();
-  const o = e.readable.getReader(), i = [];
-  let a = 0;
+async function I(t) {
+  const e = new CompressionStream("deflate"), n = e.writable.getWriter();
+  n.write(t), n.close();
+  const r = e.readable.getReader(), o = [];
+  let i = 0;
   for (; ; ) {
-    const { done: s, value: l } = await o.read();
-    if (s) break;
-    i.push(l), a += l.length;
+    const { done: u, value: c } = await r.read();
+    if (u) break;
+    o.push(c), i += c.length;
   }
-  const c = new Uint8Array(a);
-  let u = 0;
-  for (const s of i)
-    c.set(s, u), u += s.length;
-  return c;
-}
-const h = new Uint32Array(256);
-for (let r = 0; r < 256; r++) {
-  let e = r;
-  for (let t = 0; t < 8; t++)
+  const s = new Uint8Array(i);
+  let f = 0;
+  for (const u of o)
+    s.set(u, f), f += u.length;
+  return s;
+}
+const b = new Uint32Array(256);
+for (let t = 0; t < 256; t++) {
+  let e = t;
+  for (let n = 0; n < 8; n++)
     e = e & 1 ? 3988292384 ^ e >>> 1 : e >>> 1;
-  h[r] = e;
+  b[t] = e;
 }
-function V(r) {
+function $(t) {
   let e = 4294967295;
-  for (let t = 0; t < r.length; t++)
-    e = h[(e ^ r[t]) & 255] ^ e >>> 8;
+  for (let n = 0; n < t.length; n++)
+    e = b[(e ^ t[n]) & 255] ^ e >>> 8;
   return (e ^ 4294967295) >>> 0;
 }
-const k = new TextEncoder();
-function w(r, e) {
-  const t = new Uint8Array(8 + e.length + 4), o = new DataView(t.buffer);
-  o.setUint32(0, e.length), t.set(k.encode(r), 4), t.set(e, 8);
-  const i = V(t.subarray(4, t.length - 4));
-  return o.setUint32(t.length - 4, i), t;
-}
-async function v(r, e, t, o) {
-  const i = new DataView(r.buffer), a = i.byteLength;
-  let c = 0;
-  for (let n = 0; n < a; n++) {
-    const f = i.getUint8(n);
-    f > c && (c = f);
+const m = new TextEncoder();
+function d(t, e) {
+  const n = new Uint8Array(8 + e.length + 4), r = new DataView(n.buffer);
+  r.setUint32(0, e.length), n.set(m.encode(t), 4), n.set(e, 8);
+  const o = $(n.subarray(4, n.length - 4));
+  return r.setUint32(n.length - 4, o), n;
+}
+function A(t) {
+  return t <= 1 ? 1 : t <= 3 ? 2 : t <= 15 ? 4 : 8;
+}
+function R(t, e, n, r) {
+  const o = 8 / r, s = Math.ceil(e / o) + 1, f = new Uint8Array(s * n), u = new DataView(f.buffer);
+  for (let c = 0; c < n; c++) {
+    u.setUint8(c * s, 0);
+    for (let a = 0; a < e; a++) {
+      const y = t.getUint8(c * e + a), h = c * s + 1 + Math.floor(a / o), w = (o - 1 - a % o) * r, g = u.getUint8(h);
+      u.setUint8(h, g | y << w);
+    }
+  }
+  return f;
+}
+const C = new Uint8Array([137, 80, 78, 71, 13, 10, 26, 10]), L = new TextDecoder();
+function x(t) {
+  switch (t) {
+    case 0:
+      return "greyscale";
+    case 2:
+      return "truecolor";
+    case 3:
+      return "indexed";
+    case 4:
+      return "greyscale-alpha";
+    case 6:
+      return "truecolor-alpha";
+    default:
+      throw new Error(`Invalid color type: ${t}`);
+  }
+}
+function P(t) {
+  switch (t) {
+    case 0:
+      return "none";
+    case 1:
+      return "adam7";
+    default:
+      throw new Error(`Invalid interlace method: ${t}`);
+  }
+}
+function V(t, e) {
+  const r = {
+    0: [1, 2, 4, 8, 16],
+    // Greyscale
+    2: [8, 16],
+    // Truecolor
+    3: [1, 2, 4, 8],
+    // Indexed
+    4: [8, 16],
+    // Greyscale with alpha
+    6: [8, 16]
+    // Truecolor with alpha
+  }[e];
+  if (!r)
+    throw new Error(`Invalid color type: ${e}`);
+  if (!r.includes(t))
+    throw new Error(
+      `Invalid bit depth ${t} for color type ${e}. Allowed: ${r.join(", ")}`
+    );
+  return !0;
+}
+function v(t, e) {
+  if (e + 12 > t.byteLength)
+    throw new Error(
+      `Chunk at offset ${e} extends beyond data (need at least 12 bytes for header)`
+    );
+  const n = t.getUint32(e, !1), r = new Uint8Array(t.buffer, t.byteOffset + e + 4, 4), o = L.decode(r), i = 8 + n + 4;
+  if (e + i > t.byteLength)
+    throw new Error(
+      `Chunk "${o}" at offset ${e} extends beyond data (chunk size: ${i}, available: ${t.byteLength - e})`
+    );
+  const s = new DataView(t.buffer, t.byteOffset + e + 8, n);
+  return {
+    type: o,
+    data: s,
+    offset: e,
+    totalSize: i
+  };
+}
+function* O(t, e = 0) {
+  let n = e;
+  for (; n < t.byteLength; ) {
+    const r = v(t, n);
+    yield r, n += r.totalSize;
   }
-  if (o.length <= c)
+}
+function M(t, e, n, r = 0) {
+  for (const o of O(t, r))
+    if (o.type === e)
+      return n(o.data);
+}
+function N(t) {
+  if (t.byteLength !== 13)
+    throw new Error(`IHDR chunk must be 13 bytes, got ${t.byteLength}`);
+  const e = t.getUint32(0, !1), n = t.getUint32(4, !1), r = t.getUint8(8), o = t.getUint8(9), i = t.getUint8(10), s = t.getUint8(11), f = t.getUint8(12);
+  if (e === 0)
+    throw new Error("IHDR width cannot be zero");
+  if (n === 0)
+    throw new Error("IHDR height cannot be zero");
+  if (i !== 0)
     throw new Error(
-      `Color palette does not have enough colors (${c + 1}). Only ${o.length} were given!`
+      `Invalid compression method: ${i}. Only 0 (deflate) is supported.`
     );
-  if (a != e * t)
+  if (s !== 0)
     throw new Error(
-      `Input does not match dimensions ${e}x${t}. Only ${a} bytes were given when ${e * t} are expected!`
+      `Invalid filter method: ${s}. Only 0 (adaptive) is supported.`
     );
-  if (a == 0)
+  V(r, o);
+  const u = x(o), c = P(f);
+  return {
+    width: e,
+    height: n,
+    bitDepth: r,
+    colorType: u,
+    compressionMethod: "deflate",
+    filterMethod: "adaptive",
+    interlaceMethod: c
+  };
+}
+function T(t) {
+  if (t.byteLength < 8)
+    throw new Error("Data too short to contain PNG signature");
+  for (let e = 0; e < 8; e++)
+    if (t.getUint8(e) !== C[e])
+      throw new Error("Invalid PNG signature");
+  return !0;
+}
+function H(t) {
+  const e = t instanceof Uint8Array ? t.buffer : t, n = t instanceof Uint8Array ? t.byteOffset : 0, r = (t instanceof Uint8Array, t.byteLength), o = new DataView(e, n, r);
+  T(o);
+  const i = M(o, "IHDR", N, 8);
+  if (i === void 0)
+    throw new Error("IHDR chunk not found in PNG");
+  return i;
+}
+async function z(t, e, n, r) {
+  const o = new DataView(t.buffer), i = o.byteLength;
+  if (i === 0)
     throw new Error("Received empty input");
-  const u = new Uint8Array([137, 80, 78, 71, 13, 10, 26, 10]), s = new Uint8Array(13), l = new DataView(s.buffer);
-  l.setUint32(0, e), l.setUint32(4, t), s[8] = 8, s[9] = 3, s[10] = 0, s[11] = 0, s[12] = 0;
-  const y = w("IHDR", s), p = new Uint8Array(o.length * 3), g = new DataView(p.buffer);
-  for (let n = 0; n <= c; n++)
-    g.setUint8(n * 3, o[n][0]), g.setUint8(n * 3 + 1, o[n][1]), g.setUint8(n * 3 + 2, o[n][2]);
-  const D = w("PLTE", p), d = e + 1, U = new Uint8Array(d * t), b = new DataView(U.buffer);
-  for (let n = 0; n < t; n++) {
-    U[n * d] = 0;
-    for (let f = 0; f < e; f++)
-      b.setUint8(n * d + 1 + f, i.getUint8(n * e + f));
+  if (i !== e * n)
+    throw new Error(
+      `Input does not match dimensions ${e}x${n}. Only ${i} bytes were given when ${e * n} are expected!`
+    );
+  let s = 0;
+  for (let l = 0; l < i; l++) {
+    const p = o.getUint8(l);
+    p > s && (s = p);
   }
-  const A = w("IDAT", await E(U)), m = w("IEND", new Uint8Array(0));
-  return x(u, y, D, A, m);
+  if (r.length <= s)
+    throw new Error(
+      `Color palette does not have enough colors (${s + 1}). Only ${r.length} were given!`
+    );
+  const f = A(s), u = new Uint8Array([137, 80, 78, 71, 13, 10, 26, 10]), c = new Uint8Array(13), a = new DataView(c.buffer);
+  a.setUint32(0, e), a.setUint32(4, n), a.setUint8(8, f), a.setUint8(9, 3), a.setUint8(10, 0), a.setUint8(11, 0), a.setUint8(12, 0);
+  const y = d("IHDR", c), h = new Uint8Array(r.length * 3), w = new DataView(h.buffer);
+  for (let l = 0; l <= s; l++)
+    w.setUint8(l * 3, r[l][0]), w.setUint8(l * 3 + 1, r[l][1]), w.setUint8(l * 3 + 2, r[l][2]);
+  const g = d("PLTE", h), U = R(o, e, n, f), D = d("IDAT", await I(U)), E = d("IEND", new Uint8Array(0));
+  return k(u, y, g, D, E);
 }
 export {
-  v as indexedPng
+  M as findChunk,
+  z as indexedPng,
+  O as iterateChunks,
+  N as readIHDR,
+  H as readPngIHDR,
+  v as scanChunk,
+  T as validatePngSignature
 };

package/dist/reader.d.ts

@@ -0,0 +1,101 @@
+/**
+ * PNG chunk reading and parsing utilities
+ */
+/**
+ * Represents a PNG chunk with its metadata and data
+ */
+export interface PngChunk {
+    /** 4-character chunk type name (e.g., "IHDR", "IDAT", "IEND") */
+    type: string;
+    /** Chunk data (excluding length, type, and CRC) */
+    data: DataView;
+    /** Offset of the chunk in the original data (points to length field) */
+    offset: number;
+    /** Total chunk size including length, type, data, and CRC */
+    totalSize: number;
+}
+/**
+ * Color type strings for PNG images
+ */
+export type ColorType = "greyscale" | "truecolor" | "indexed" | "greyscale-alpha" | "truecolor-alpha";
+/**
+ * Interlace method strings
+ */
+export type InterlaceMethod = "none" | "adam7";
+/**
+ * Bits per sample or palette index (1, 2, 4, 8, or 16)
+ */
+export type BitDepth = 1 | 2 | 4 | 8 | 16;
+/**
+ * Parsed IHDR (Image Header) chunk data
+ */
+export interface IHDRData {
+    /** Image width in pixels */
+    width: number;
+    /** Image height in pixels */
+    height: number;
+    /** Bits per sample or palette index (1, 2, 4, 8, or 16) */
+    bitDepth: BitDepth;
+    /** Color type of the image */
+    colorType: ColorType;
+    /** Compression method (always 'deflate' for valid PNGs) */
+    compressionMethod: "deflate";
+    /** Filter method (always 'adaptive' for valid PNGs) */
+    filterMethod: "adaptive";
+    /** Interlace method */
+    interlaceMethod: InterlaceMethod;
+}
+/**
+ * Scans a PNG chunk at the given offset in a DataView
+ *
+ * @param view - DataView of the PNG data
+ * @param offset - Byte offset where the chunk starts (at the length field)
+ * @returns The parsed chunk information
+ * @throws Error if the offset is out of bounds or chunk is malformed
+ */
+export declare function scanChunk(view: DataView, offset: number): PngChunk;
+/**
+ * Generator that iterates over all chunks in a PNG DataView
+ *
+ * @param view - DataView of the PNG data (should start after PNG signature)
+ * @param startOffset - Byte offset to start scanning from (default: 0, assumes signature already skipped)
+ * @yields Each chunk in sequence
+ */
+export declare function iterateChunks(view: DataView, startOffset?: number): Generator<PngChunk, void, unknown>;
+/**
+ * Finds a chunk by its type name and calls a reader function on it
+ *
+ * @param view - DataView of the PNG data (after signature)
+ * @param chunkType - The 4-character chunk type to find (e.g., "IHDR")
+ * @param reader - Function to call with the chunk's data DataView
+ * @param startOffset - Byte offset to start scanning from (default: 0)
+ * @returns The result of the reader function, or undefined if chunk not found
+ */
+export declare function findChunk<T>(view: DataView, chunkType: string, reader: (data: DataView) => T, startOffset?: number): T | undefined;
+/**
+ * Reads and parses an IHDR chunk from its data
+ *
+ * @param data - DataView of the IHDR chunk data (13 bytes)
+ * @returns Parsed IHDR data with human-readable type strings
+ * @throws Error if the IHDR data is invalid
+ */
+export declare function readIHDR(data: DataView): IHDRData;
+/**
+ * Validates that the data starts with a valid PNG signature
+ *
+ * @param view - DataView of the data to check
+ * @returns true if the signature is valid
+ * @throws Error if the signature is invalid or data is too short
+ */
+export declare function validatePngSignature(view: DataView): boolean;
+/**
+ * Reads a PNG and extracts the parsed IHDR data
+ *
+ * This is a convenience function that combines signature validation,
+ * chunk scanning, and IHDR parsing.
+ *
+ * @param data - PNG file data as Uint8Array or ArrayBuffer
+ * @returns Parsed IHDR data with human-readable type strings
+ * @throws Error if the PNG is invalid or IHDR chunk is not found
+ */
+export declare function readPngIHDR(data: Uint8Array | ArrayBuffer): IHDRData;

package/dist/writer.d.ts

@@ -0,0 +1,15 @@
+/**
+ * Calculate the optimal bit depth for indexed PNG based on the maximum color index
+ * @param maxIndex - The highest palette index used in the image
+ * @returns The bit depth (1, 2, 4, or 8)
+ */
+export declare function calculateBitDepth(maxIndex: number): 1 | 2 | 4 | 8;
+/**
+ * Pack pixel indices into bytes according to the specified bit depth
+ * @param inputView - DataView of original pixel data (1 byte per pixel)
+ * @param width - Image width in pixels
+ * @param height - Image height in pixels
+ * @param bitDepth - Target bit depth (1, 2, 4, or 8)
+ * @returns Packed image data with filter bytes for each row
+ */
+export declare function packPixelData(inputView: DataView, width: number, height: number, bitDepth: 1 | 2 | 4 | 8): Uint8Array<ArrayBuffer>;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@levischuck/tiny-png",
-  "version": "0.0.8",
+  "version": "0.2.0",
   "type": "module",
   "license": "MIT",
   "main": "./dist/index.js",