@levischuck/tiny-png 0.0.5 → 0.1.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,11 @@
 /**
- * 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 +16,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,87 @@
-function x(...r) {
-  const e = new Uint8Array(
-    r.reduceRight((o, i) => o + i.length, 0)
+function V(...n) {
+  const t = new Uint8Array(
+    n.reduceRight((r, o) => r + o.length, 0)
   );
-  let t = 0;
-  for (const o of r)
-    e.set(o, t), t += o.length;
-  return e;
+  let e = 0;
+  for (const r of n)
+    t.set(r, e), e += r.length;
+  return t;
 }
-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 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;
   for (; ; ) {
-    const { done: s, value: l } = await o.read();
-    if (s) break;
-    i.push(l), a += l.length;
+    const { done: l, value: a } = await r.read();
+    if (l) break;
+    o.push(a), u += a.length;
   }
-  const c = new Uint8Array(a);
-  let u = 0;
-  for (const s of i)
-    c.set(s, u), u += s.length;
-  return c;
+  const i = new Uint8Array(u);
+  let f = 0;
+  for (const l of o)
+    i.set(l, f), f += l.length;
+  return i;
 }
-const h = new Uint32Array(256);
-for (let r = 0; r < 256; r++) {
-  let e = r;
-  for (let t = 0; t < 8; t++)
-    e = e & 1 ? 3988292384 ^ e >>> 1 : e >>> 1;
-  h[r] = e;
+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 V(r) {
-  let e = 4294967295;
-  for (let t = 0; t < r.length; t++)
-    e = h[(e ^ r[t]) & 255] ^ e >>> 8;
-  return (e ^ 4294967295) >>> 0;
+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 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;
+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;
 }
-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);
+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);
+    }
   }
-  if (o.length <= c)
+  return f;
+}
+async function P(n, t, e, r) {
+  const o = new DataView(n.buffer), u = o.byteLength;
+  if (u === 0)
+    throw new Error("Received empty input");
+  if (u !== t * e)
     throw new Error(
-      `Color palette does not have enough colors (${c + 1}). Only ${o.length} were given!`
+      `Input does not match dimensions ${t}x${e}. Only ${u} bytes were given when ${t * e} are expected!`
     );
-  if (a != e * t)
+  let i = 0;
+  for (let c = 0; c < u; c++) {
+    const h = o.getUint8(c);
+    h > i && (i = h);
+  }
+  if (r.length <= i)
     throw new Error(
-      `Input does not match dimensions ${e}x${t}. Only ${a} bytes were given when ${e * t} are expected!`
+      `Color palette does not have enough colors (${i + 1}). Only ${r.length} were given!`
     );
-  if (a == 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));
-  }
-  const A = w("IDAT", await E(U)), m = w("IEND", new Uint8Array(0));
-  return x(u, y, D, A, m);
+  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);
 }
 export {
-  v as indexedPng
+  P as indexedPng
 };

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@levischuck/tiny-png",
-  "version": "0.0.5",
+  "version": "0.1.0",
   "type": "module",
   "license": "MIT",
   "main": "./dist/index.js",
@@ -32,7 +32,8 @@
   "scripts": {
     "build": "vite build",
     "type-check": "bunx tsc --noEmit",
-    "build:jsr": "echo Nothing to build"
+    "build:jsr": "echo Nothing to build",
+    "lint": "oxlint -c ../../.oxlintrc.json"
   },
   "devDependencies": {
     "@types/bun": "latest"