@levischuck/tiny-png 0.1.0 → 0.2.0

package/dist/index.d.ts

@@ -1,3 +1,4 @@
+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 256 colors are supported
  *

package/dist/index.js

@@ -1,87 +1,215 @@
-function V(...n) {
-  const t = new Uint8Array(
-    n.reduceRight((r, o) => r + o.length, 0)
+function k(...t) {
+  const e = new Uint8Array(
+    t.reduceRight((r, o) => r + o.length, 0)
   );
-  let e = 0;
-  for (const r of n)
-    t.set(r, e), e += r.length;
-  return t;
-}
-async function k(n) {
-  const t = new CompressionStream("deflate"), e = t.writable.getWriter();
-  e.write(n), e.close();
-  const r = t.readable.getReader(), o = [];
-  let u = 0;
+  let n = 0;
+  for (const r of t)
+    e.set(r, n), n += r.length;
+  return e;
+}
+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: l, value: a } = await r.read();
-    if (l) break;
-    o.push(a), u += a.length;
+    const { done: u, value: c } = await r.read();
+    if (u) break;
+    o.push(c), i += c.length;
   }
-  const i = new Uint8Array(u);
+  const s = new Uint8Array(i);
   let f = 0;
-  for (const l of o)
-    i.set(l, f), f += l.length;
-  return i;
+  for (const u of o)
+    s.set(u, f), f += u.length;
+  return s;
 }
-const d = new Uint32Array(256);
-for (let n = 0; n < 256; n++) {
-  let t = n;
-  for (let e = 0; e < 8; e++)
-    t = t & 1 ? 3988292384 ^ t >>> 1 : t >>> 1;
-  d[n] = t;
-}
-function x(n) {
-  let t = 4294967295;
-  for (let e = 0; e < n.length; e++)
-    t = d[(t ^ n[e]) & 255] ^ t >>> 8;
-  return (t ^ 4294967295) >>> 0;
-}
-const E = new TextEncoder();
-function p(n, t) {
-  const e = new Uint8Array(8 + t.length + 4), r = new DataView(e.buffer);
-  r.setUint32(0, t.length), e.set(E.encode(n), 4), e.set(t, 8);
-  const o = x(e.subarray(4, e.length - 4));
-  return r.setUint32(e.length - 4, o), e;
-}
-function R(n) {
-  return n <= 1 ? 1 : n <= 3 ? 2 : n <= 15 ? 4 : 8;
-}
-function m(n, t, e, r) {
-  const o = 8 / r, i = Math.ceil(t / o) + 1, f = new Uint8Array(i * e), l = new DataView(f.buffer);
-  for (let a = 0; a < e; a++) {
-    l.setUint8(a * i, 0);
-    for (let s = 0; s < t; s++) {
-      const g = n.getUint8(a * t + s), w = a * i + 1 + Math.floor(s / o), U = (o - 1 - s % o) * r, y = l.getUint8(w);
-      l.setUint8(w, y | g << U);
+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;
+  b[t] = e;
+}
+function $(t) {
+  let e = 4294967295;
+  for (let n = 0; n < t.length; n++)
+    e = b[(e ^ t[n]) & 255] ^ e >>> 8;
+  return (e ^ 4294967295) >>> 0;
+}
+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;
 }
-async function P(n, t, e, r) {
-  const o = new DataView(n.buffer), u = o.byteLength;
-  if (u === 0)
+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;
+  }
+}
+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(
+      `Invalid compression method: ${i}. Only 0 (deflate) is supported.`
+    );
+  if (s !== 0)
+    throw new Error(
+      `Invalid filter method: ${s}. Only 0 (adaptive) is supported.`
+    );
+  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");
-  if (u !== t * e)
+  if (i !== e * n)
     throw new Error(
-      `Input does not match dimensions ${t}x${e}. Only ${u} bytes were given when ${t * e} are expected!`
+      `Input does not match dimensions ${e}x${n}. Only ${i} bytes were given when ${e * n} are expected!`
     );
-  let i = 0;
-  for (let c = 0; c < u; c++) {
-    const h = o.getUint8(c);
-    h > i && (i = h);
+  let s = 0;
+  for (let l = 0; l < i; l++) {
+    const p = o.getUint8(l);
+    p > s && (s = p);
   }
-  if (r.length <= i)
+  if (r.length <= s)
     throw new Error(
-      `Color palette does not have enough colors (${i + 1}). Only ${r.length} were given!`
+      `Color palette does not have enough colors (${s + 1}). Only ${r.length} were given!`
     );
-  const f = R(i), l = new Uint8Array([137, 80, 78, 71, 13, 10, 26, 10]), a = new Uint8Array(13), s = new DataView(a.buffer);
-  s.setUint32(0, t), s.setUint32(4, e), s.setUint8(8, f), s.setUint8(9, 3), s.setUint8(10, 0), s.setUint8(11, 0), s.setUint8(12, 0);
-  const g = p("IHDR", a), w = new Uint8Array(r.length * 3), U = new DataView(w.buffer);
-  for (let c = 0; c <= i; c++)
-    U.setUint8(c * 3, r[c][0]), U.setUint8(c * 3 + 1, r[c][1]), U.setUint8(c * 3 + 2, r[c][2]);
-  const y = p("PLTE", w), b = m(o, t, e, f), D = p("IDAT", await k(b)), A = p("IEND", new Uint8Array(0));
-  return V(l, g, y, D, A);
+  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 {
-  P 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.1.0",
+  "version": "0.2.0",
   "type": "module",
   "license": "MIT",
   "main": "./dist/index.js",