@chr33s/pdf-upng 5.0.0 → 5.0.2

package/package.json

@@ -1,10 +1,14 @@
 {
   "name": "@chr33s/pdf-upng",
   "license": "MIT",
-  "version": "5.0.0",
+  "version": "5.0.2",
   "description": "Small, fast and advanced PNG / APNG encoder and decoder",
   "type": "module",
   "sideEffects": false,
+  "files": [
+    "dist/**",
+    "src/**"
+  ],
   "exports": {
     ".": {
       "types": "./dist/index.d.ts",
@@ -37,7 +41,7 @@
     "conversion"
   ],
   "dependencies": {
-    "@chr33s/pdf-common": "file:../common"
+    "@chr33s/pdf-common": "5.0.2"
   },
   "devDependencies": {
     "typescript": "5.9.3",

package/test/bin.test.ts

@@ -1,173 +0,0 @@
-import { describe, expect, test } from "vitest";
-import { Bin } from "../src/bin.js";
-
-describe("nextZero", () => {
-  test("returns index of first zero starting at p", () => {
-    const data = new Uint8Array([1, 2, 3, 0, 4]);
-    expect(Bin.nextZero(data, 0)).toBe(3);
-  });
-
-  test("returns p when it already points to zero", () => {
-    const data = new Uint8Array([1, 2, 0, 4]);
-    expect(Bin.nextZero(data, 2)).toBe(2);
-  });
-});
-
-describe("readUshort / writeUshort", () => {
-  test("reads a big-endian unsigned short written by writeUshort", () => {
-    const buff = new Uint8Array(4);
-    const value = 0x1234; // 4660
-    Bin.writeUshort(buff, 1, value);
-    expect(buff[1]).toBe(0x12);
-    expect(buff[2]).toBe(0x34);
-
-    const readValue = Bin.readUshort(buff, 1);
-    expect(readValue).toBe(value);
-  });
-
-  test("handles minimum and maximum ushort values", () => {
-    const buff = new Uint8Array(4);
-
-    Bin.writeUshort(buff, 0, 0);
-    expect(Bin.readUshort(buff, 0)).toBe(0);
-
-    Bin.writeUshort(buff, 0, 0xffff);
-    expect(Bin.readUshort(buff, 0)).toBe(0xffff);
-  });
-});
-
-describe("readUint / writeUint", () => {
-  test("reads a big-endian unsigned int written by writeUint", () => {
-    const buff = new Uint8Array(8);
-    const value = 0x12345678; // 305419896
-    Bin.writeUint(buff, 2, value);
-
-    expect(buff[2]).toBe(0x12);
-    expect(buff[3]).toBe(0x34);
-    expect(buff[4]).toBe(0x56);
-    expect(buff[5]).toBe(0x78);
-
-    const readValue = Bin.readUint(buff, 2);
-    expect(readValue).toBe(value);
-  });
-
-  test("handles minimum and maximum 32-bit unsigned values", () => {
-    const buff = new Uint8Array(4);
-
-    Bin.writeUint(buff, 0, 0);
-    expect(Bin.readUint(buff, 0)).toBe(0);
-
-    const max = 0xffffffff; // 4294967295
-    Bin.writeUint(buff, 0, max);
-    expect(Bin.readUint(buff, 0)).toBe(max);
-  });
-});
-
-describe("readASCII / writeASCII", () => {
-  test("writes and reads ASCII strings correctly", () => {
-    const buff = new Uint8Array(10);
-    const s = "Hello";
-    Bin.writeASCII(buff, 2, s);
-
-    // Raw bytes
-    expect(Array.from(buff.slice(2, 7))).toEqual([
-      "H".charCodeAt(0),
-      "e".charCodeAt(0),
-      "l".charCodeAt(0),
-      "l".charCodeAt(0),
-      "o".charCodeAt(0),
-    ]);
-
-    const read = Bin.readASCII(buff, 2, s.length);
-    expect(read).toBe(s);
-  });
-
-  test("can write shorter strings without touching earlier bytes", () => {
-    const buff = new Uint8Array(5).fill(0xff);
-    Bin.writeASCII(buff, 1, "A");
-    expect(buff[0]).toBe(0xff);
-    expect(buff[1]).toBe("A".charCodeAt(0));
-  });
-});
-
-describe("readBytes", () => {
-  test("returns a JS array slice of the specified bytes", () => {
-    const buff = new Uint8Array([10, 20, 30, 40, 50]);
-    const arr = Bin.readBytes(buff, 1, 3);
-    expect(arr).toEqual([20, 30, 40]);
-  });
-
-  test("works with length 0", () => {
-    const buff = new Uint8Array([1, 2, 3]);
-    const arr = Bin.readBytes(buff, 1, 0);
-    expect(arr).toEqual([]);
-  });
-});
-
-describe("pad", () => {
-  test("adds a leading zero for single-character strings", () => {
-    expect(Bin.pad("a")).toBe("0a");
-    expect(Bin.pad("1")).toBe("01");
-  });
-
-  test("returns the original string if length >= 2", () => {
-    expect(Bin.pad("10")).toBe("10");
-    expect(Bin.pad("abc")).toBe("abc");
-  });
-});
-
-describe("readUTF8", () => {
-  test("decodes valid UTF-8 sequences", () => {
-    // "hé" in UTF-8
-    const encoder = new TextEncoder();
-    const s = "hé";
-    const bytes = encoder.encode(s); // Uint8Array
-
-    const buff = new Uint8Array(10);
-    buff.set(bytes, 2);
-
-    const decoded = Bin.readUTF8(buff, 2, bytes.length);
-    expect(decoded).toBe(s);
-  });
-
-  test("falls back to ASCII when decodeURIComponent throws", () => {
-    // Create bytes that produce an invalid percent-escape sequence
-    // '%' followed by non-hex characters
-    const _buff = new Uint8Array([37, 71, 71]); // '%GG'
-    // readUTF8 will create string "%25%47%47", which is valid,
-    // so we instead force a bad sequence by hand:
-    // We'll directly test the catch path by constructing an impossible pattern:
-    //
-    // To get into catch, we need decodeURIComponent to throw.
-    // One way is to craft an incomplete escape at end: e.g. "%E2%82"
-    const invalid = new Uint8Array([
-      0xe2, // 226
-      0x82, // 130
-    ]);
-    const bigBuff = new Uint8Array(10);
-    bigBuff.set(invalid, 0);
-
-    // Monkey-patch pad+readASCII behavior is not necessary,
-    // instead we rely on decodeURIComponent("%e2%82") throwing.
-    const result = Bin.readUTF8(bigBuff, 0, invalid.length);
-
-    // Fallback is ASCII for same bytes
-    const ascii = Bin.readASCII(bigBuff, 0, invalid.length);
-    expect(result).toBe(ascii);
-  });
-
-  test("matches ASCII for plain ASCII strings", () => {
-    const text = "Hello";
-    const encoder = new TextEncoder();
-    const bytes = encoder.encode(text);
-
-    const buff = new Uint8Array(10);
-    buff.set(bytes, 1);
-
-    const utf8 = Bin.readUTF8(buff, 1, bytes.length);
-    const ascii = Bin.readASCII(buff, 1, bytes.length);
-
-    expect(utf8).toBe(text);
-    expect(utf8).toBe(ascii);
-  });
-});

package/test/crc.test.ts

@@ -1,71 +0,0 @@
-import { describe, expect, test } from "vitest";
-import { CRC } from "../src/crc.js";
-
-describe("table", () => {
-  test("has 256 entries", () => {
-    expect(CRC.table).toBeInstanceOf(Uint32Array);
-    expect(CRC.table.length).toBe(256);
-  });
-});
-
-describe("update", () => {
-  test("returns the same value when updating with zero-length buffer", () => {
-    const initial = 0x12345678;
-    const buf = new Uint8Array([1, 2, 3, 4]);
-    const result = CRC.update(initial, buf, 0, 0);
-    expect(result).toBe(initial);
-  });
-
-  test("updates CRC incrementally equivalent to one-shot", () => {
-    const text = "Hello, world!";
-    const bytes = new TextEncoder().encode(text);
-
-    const full = CRC.update(0xffffffff, bytes, 0, bytes.length);
-
-    const mid = Math.floor(bytes.length / 2);
-    const part1 = CRC.update(0xffffffff, bytes, 0, mid);
-    const part2 = CRC.update(part1, bytes, mid, bytes.length - mid);
-
-    expect(part2 >>> 0).toBe(full >>> 0);
-  });
-
-  test("respects offset and length", () => {
-    const buf = new Uint8Array([0, 1, 2, 3, 4, 5]);
-    const c1 = CRC.update(0xffffffff, buf, 1, 3);
-
-    const slice = buf.slice(1, 4);
-    const c2 = CRC.update(0xffffffff, slice, 0, slice.length);
-
-    expect(c1 >>> 0).toBe(c2 >>> 0);
-  });
-});
-
-describe("crc", () => {
-  test("matches known CRC-32 values for test vectors", () => {
-    const enc = new TextEncoder();
-
-    // Empty buffer (standard CRC-32)
-    expect(CRC.crc(new Uint8Array([]), 0, 0) >>> 0).toBe(0x00000000);
-
-    // "123456789" -> 0xCBF43926
-    const v1 = enc.encode("123456789");
-    expect(CRC.crc(v1, 0, v1.length) >>> 0).toBe(0xcbf43926);
-
-    // Just verify that we return a valid 32-bit value for another string
-    const v2 = enc.encode("Hello, world!");
-    const crc2 = CRC.crc(v2, 0, v2.length) >>> 0;
-    expect(crc2).toBeGreaterThanOrEqual(0);
-    expect(crc2).toBeLessThanOrEqual(0xffffffff);
-  });
-
-  test("computes CRC on a subrange using offset and length", () => {
-    const enc = new TextEncoder();
-    const full = enc.encode("ABCDEF");
-    const subCrc = CRC.crc(full, 1, 3); // "BCD"
-
-    const sub = enc.encode("BCD");
-    const expected = CRC.crc(sub, 0, sub.length);
-
-    expect(subCrc >>> 0).toBe(expected >>> 0);
-  });
-});

package/test/index.test.ts

@@ -1,9 +0,0 @@
-import { describe, expect, test } from "vitest";
-import UPNG from "../src/index.js";
-
-describe("UPNG public API", () => {
-  test("exposes encode/decode helpers", () => {
-    expect(typeof UPNG.encode).toBe("function");
-    expect(typeof UPNG.decode).toBe("function");
-  });
-});

package/test/inflator.test.ts

@@ -1,227 +0,0 @@
-import { deflate } from "@chr33s/pdf-common";
-import { describe, expect, test } from "vitest";
-import { Inflator } from "../src/inflator.js";
-
-describe("Inflator tables initialization", () => {
-  const D = Inflator.D;
-
-  test("creates all expected table types with correct lengths", () => {
-    expect(D.m).toBeInstanceOf(Uint16Array);
-    expect(D.v).toBeInstanceOf(Uint16Array);
-    expect(D.B).toBeInstanceOf(Uint16Array);
-    expect(D.h).toBeInstanceOf(Uint32Array);
-    expect(D.g).toBeInstanceOf(Uint16Array);
-    expect(D.A).toBeInstanceOf(Uint16Array);
-    expect(D.k).toBeInstanceOf(Uint16Array);
-    expect(D.n).toBeInstanceOf(Uint16Array);
-    expect(D.C).toBeInstanceOf(Uint16Array);
-    expect(D.i).toBeInstanceOf(Uint16Array);
-    expect(D.r).toBeInstanceOf(Uint32Array);
-    expect(D.f).toBeInstanceOf(Uint32Array);
-    expect(D.l).toBeInstanceOf(Uint32Array);
-    expect(D.u).toBeInstanceOf(Uint32Array);
-    expect(D.q).toBeInstanceOf(Uint16Array);
-    expect(D.j).toBeInstanceOf(Uint16Array);
-
-    expect(D.m.length).toBe(16);
-    expect(D.v.length).toBe(16);
-    expect(D.B.length).toBe(32);
-    expect(D.h.length).toBe(32);
-    expect(D.g.length).toBe(512);
-    expect(D.A.length).toBe(32);
-    expect(D.k.length).toBe(32768);
-    expect(D.n.length).toBe(32768);
-    expect(D.C.length).toBe(512);
-    expect(D.i.length).toBe(1 << 15);
-    expect(D.r.length).toBe(286);
-    expect(D.f.length).toBe(30);
-    expect(D.l.length).toBe(19);
-    expect(D.u.length).toBe(15000);
-    expect(D.q.length).toBe(1 << 16);
-    expect(D.j.length).toBe(1 << 15);
-  });
-
-  test("precomputes correct fixed Huffman length and distance tables for some entries", () => {
-    // For fixed Huffman, the first 144 literal/length symbols use 8-bit codes.
-    // `tables.s` is the canonical (code,length) pair array backing `g`.
-    // Check some sample lengths.
-    const s = D.s;
-    // s is [code0, len0, code1, len1, ...]
-    const len0 = s[1];
-    const len143 = s[(143 << 1) + 1];
-    const len144 = s[(144 << 1) + 1];
-
-    expect(len0).toBe(8);
-    expect(len143).toBe(8);
-    expect(len144).toBe(9); // start of the 9-bit block
-
-    // Distance codes for fixed Huffman use 5 bits each.
-    const t = D.t;
-    const distLen0 = t[1];
-    const distLen29 = t[(29 << 1) + 1];
-    expect(distLen0).toBe(5);
-    expect(distLen29).toBe(5);
-  });
-
-  test("bit-reversal table i is self-consistent for a few sample entries", () => {
-    const i = D.i;
-    // For some simple patterns, reversing twice should give the original index
-    const samples = [0, 1, 0b101010101010101, 0b111000000000000, 0x7fff];
-    for (const v of samples) {
-      const rev = i[v];
-      const rev2 = i[rev];
-      expect(rev2).toBe(v);
-    }
-  });
-});
-
-describe("Inflator helpers", () => {
-  test("H expands buffer capacity when needed and preserves content", () => {
-    const original = new Uint8Array([1, 2, 3, 4]);
-    const same = Inflator.H(original, 4);
-    expect(same).toBe(original);
-
-    const expanded = Inflator.H(original, 10);
-    expect(expanded).not.toBe(original);
-    expect(expanded.length).toBeGreaterThanOrEqual(10);
-    expect(Array.from(expanded.slice(0, 4))).toEqual([1, 2, 3, 4]);
-  });
-
-  test("C_inner assigns canonical codes consistently with straightforward implementation", () => {
-    // Build a small length array: 4 symbols with lengths [2,3,3,1]
-    const lengths = [2, 3, 3, 1];
-    // o: [code0,len0,code1,len1,...] initially codes are 0
-    const o: number[] = [];
-    for (const len of lengths) {
-      o.push(0, len);
-    }
-
-    // Run C_inner with max bits = 3
-    Inflator.C_inner(o, 3);
-
-    // Our own simple canonical-code computation for comparison
-    const maxBits = 3;
-    const blCount: number[] = Array.from({ length: maxBits + 1 }).fill(0) as number[];
-    lengths.forEach((l) => {
-      if (l > 0) blCount[l]++;
-    });
-
-    const nextCode: number[] = Array.from({ length: maxBits + 1 }).fill(0) as number[];
-    let code = 0;
-    for (let bits = 1; bits <= maxBits; bits++) {
-      code = (code + blCount[bits - 1]) << 1;
-      nextCode[bits] = code;
-    }
-
-    const expectedCodes: number[] = [];
-    for (const len of lengths) {
-      if (len === 0) {
-        expectedCodes.push(0);
-      } else {
-        const c = nextCode[len];
-        expectedCodes.push(c);
-        nextCode[len]++;
-      }
-    }
-
-    const actualCodes = [];
-    for (let idx = 0; idx < o.length; idx += 2) {
-      actualCodes.push(o[idx]);
-    }
-
-    expect(actualCodes).toEqual(expectedCodes);
-  });
-
-  test("d maps lengths into (code,length) pairs and returns max length", () => {
-    const lengths = [3, 0, 5, 1]; // I = 4 symbols
-    const target: number[] = Array.from({ length: 8 }).fill(0) as number[]; // length = 8 => 4 pairs
-    const maxBits = Inflator.d(lengths, 0, lengths.length, target);
-
-    // target: [code0,len0, code1,len1, ...] but C_inner hasn't run yet,
-    // so codes should all be 0 and lengths should match.
-    expect(target).toEqual([0, 3, 0, 0, 0, 5, 0, 1]);
-    expect(maxBits).toBe(5);
-  });
-});
-
-describe("Inflator.inflateRaw", () => {
-  test("returns empty output for special case header 0x03 0x00", () => {
-    const input = new Uint8Array([0x03, 0x00]); // triggers early-return branch
-    const result = Inflator.inflateRaw(input);
-    expect(result).toBeInstanceOf(Uint8Array);
-    expect(result.length).toBe(0);
-  });
-
-  test("inflates a stored (uncompressed) block correctly", () => {
-    // Deflate "ABC" as a single stored block:
-    // BFINAL=1, BTYPE=00
-    // LEN=3, NLEN=~3 (0xFFFC)
-    // raw data: 0x41,0x42,0x43
-    //
-    // Bits: 1 (final) + 00 (stored) => 001 => 0x01 at low bits
-    // We'll assemble minimal correct stored block bytes:
-    const stored = new Uint8Array([
-      0x01, // BFINAL=1,BTYPE=00,and padding
-      0x03,
-      0x00, // LEN = 3
-      0xfc,
-      0xff, // NLEN = ~3
-      0x41,
-      0x42,
-      0x43, // "ABC"
-    ]);
-
-    const out = Inflator.inflateRaw(stored);
-    expect(new TextDecoder().decode(out)).toBe("ABC");
-  });
-
-  test("inflates a fixed Huffman block identically to deflateRaw", async () => {
-    const text = "Hello, world! Hello, world!";
-    const encoder = new TextEncoder();
-    const data = encoder.encode(text);
-
-    const compressed = await deflate(data, "deflate-raw");
-    const ours = Inflator.inflateRaw(compressed);
-
-    expect(new TextDecoder().decode(ours)).toBe(text);
-  });
-
-  test("inflates a dynamic Huffman block identically to deflateRaw", async () => {
-    const text = "Dynamic Huffman blocks are used for better compression on varied data.";
-    const encoder = new TextEncoder();
-    const data = encoder.encode(text);
-
-    // deflateRaw uses dynamic Huffman by default
-    const compressed = await deflate(data, "deflate-raw"); // contains dynamic blocks
-    const ours = Inflator.inflateRaw(compressed);
-
-    expect(new TextDecoder().decode(ours)).toBe(text);
-  });
-
-  test("supports inflating into a preallocated output buffer", async () => {
-    const text = "Preallocated output buffer test.";
-    const encoder = new TextEncoder();
-    const data = encoder.encode(text);
-
-    const compressed = await deflate(data, "deflate-raw");
-
-    // Preallocate a buffer with exactly the required size
-    const out = new Uint8Array(text.length);
-    const result = Inflator.inflateRaw(compressed, out);
-
-    // Using supplied buffer should either reuse or slice it exactly to size
-    expect(result.length).toBe(text.length);
-    expect(new TextDecoder().decode(result)).toBe(text);
-  });
-
-  test("grows output buffer as needed when not provided", async () => {
-    const text = "X".repeat(100000); // big to force resizing via H()
-    const encoder = new TextEncoder();
-    const data = encoder.encode(text);
-    const compressed = await deflate(data, "deflate-raw");
-
-    const result = Inflator.inflateRaw(compressed);
-    expect(result.length).toBe(text.length);
-    expect(new TextDecoder().decode(result)).toBe(text);
-  });
-});

package/test/quantizer.test.ts

@@ -1,323 +0,0 @@
-import { beforeEach, describe, expect, test } from "vitest";
-import { Quantizer } from "../src/quantizer.js";
-
-describe("Quantizer.M4", () => {
-  test("multVec multiplies 4x4 matrix by 4-vector", () => {
-    const m = [1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16];
-    const v = [1, 0, -1, 2];
-    const r = Quantizer.M4.multVec(m, v);
-
-    // m = [1,2,3,4; 5,6,7,8; 9,10,11,12; 13,14,15,16] row-major
-    // v = [1, 0, -1, 2]
-    // Result: row_i dot v = m[i*4]*1 + m[i*4+1]*0 + m[i*4+2]*(-1) + m[i*4+3]*2
-    expect(r).toEqual([6, 14, 22, 30]);
-  });
-
-  test("dot computes 4D dot product", () => {
-    const x = [1, 2, 3, 4];
-    const y = [4, 3, 2, 1];
-    const d = Quantizer.M4.dot(x, y);
-    expect(d).toBe(1 * 4 + 2 * 3 + 3 * 2 + 4 * 1);
-  });
-
-  test("sml scales 4-vector", () => {
-    const v = [1, -2, 3, -4];
-    const s = Quantizer.M4.sml(2, v);
-    expect(s).toEqual([2, -4, 6, -8]);
-  });
-});
-
-describe("Quantizer.basic math helpers", () => {
-  test("dist computes squared 4D distance", () => {
-    const q = [0, 0, 0, 0];
-    const d = Quantizer.dist(q, 1, 2, 3, 4);
-    expect(d).toBe(1 * 1 + 2 * 2 + 3 * 3 + 4 * 4);
-  });
-
-  test("vecDot matches manual computation", () => {
-    const px = new Uint8Array([10, 20, 30, 40]);
-    const e = [0.1, 0.2, 0.3, 0.4];
-    const v = Quantizer.vecDot(px, 0, e);
-    const manual = 10 * 0.1 + 20 * 0.2 + 30 * 0.3 + 40 * 0.4;
-    expect(v).toBeCloseTo(manual);
-  });
-
-  test("planeDst returns signed distance from plane", () => {
-    const est = {
-      e: [1, 0, 0, 0],
-      eMq: 0.5,
-    };
-    const d1 = Quantizer.planeDst(est, 1, 0, 0, 0);
-    const d2 = Quantizer.planeDst(est, 0, 0, 0, 0);
-    expect(d1).toBeCloseTo(0.5);
-    expect(d2).toBeCloseTo(-0.5);
-  });
-});
-
-describe("Quantizer.stats and estats", () => {
-  test("stats computes count, means and covariance-like accumulators", () => {
-    // 2 pixels: (255,0,0,255) and (0,255,0,255)
-    const img = new Uint8Array([255, 0, 0, 255, 0, 255, 0, 255]);
-    const s = Quantizer.stats(img, 0, img.length);
-    expect(s.N).toBe(2);
-    // Means are in [0,1] range
-    const iN = 1 / s.N;
-    expect(s.m[0] * iN).toBeCloseTo(0.5, 5);
-    expect(s.m[1] * iN).toBeCloseTo(0.5, 5);
-    expect(s.m[2] * iN).toBeCloseTo(0, 5);
-    expect(s.m[3] * iN).toBeCloseTo(1, 5);
-  });
-
-  test("estats produces expected structure and stable eigenvector", () => {
-    const img = new Uint8Array([255, 0, 0, 255, 0, 255, 0, 255, 0, 0, 255, 255]);
-    const stats = Quantizer.stats(img, 0, img.length);
-    const est = Quantizer.estats(stats);
-
-    expect(est).toHaveProperty("Cov");
-    expect(est).toHaveProperty("q");
-    expect(est).toHaveProperty("e");
-    expect(est).toHaveProperty("L");
-    expect(est).toHaveProperty("eMq255");
-    expect(est).toHaveProperty("eMq");
-    expect(est).toHaveProperty("rgba");
-
-    // q is the mean color in [0,1]
-    expect(est.q.length).toBe(4);
-    expect(est.L).toBeGreaterThanOrEqual(0);
-    // rgba is packed 8-bit channels
-    expect(est.rgba >>> 0).toBeGreaterThanOrEqual(0);
-  });
-});
-
-describe("Quantizer.splitPixels", () => {
-  test("splits pixels into two groups based on plane", () => {
-    // Four pixels: two dark, two bright
-    const img = new Uint8Array([
-      0,
-      0,
-      0,
-      255, // 0
-      10,
-      10,
-      10,
-      255, // 4
-      200,
-      200,
-      200,
-      255, // 8
-      250,
-      250,
-      250,
-      255, // 12
-    ]);
-    const img32 = new Uint32Array(img.buffer);
-
-    // Plane roughly on brightness
-    const e = [1, 1, 1, 0];
-    const mq = 200 * 3; // threshold ~sum of channels
-    const splitIdx = Quantizer.splitPixels(img, img32, 0, img.length, e, mq);
-
-    // All pixels before splitIdx are <= mq, all after are > mq
-    for (let i = 0; i < splitIdx; i += 4) {
-      const v = Quantizer.vecDot(img, i, e);
-      expect(v).toBeLessThanOrEqual(mq);
-    }
-    for (let i = splitIdx; i < img.length; i += 4) {
-      const v = Quantizer.vecDot(img, i, e);
-      expect(v).toBeGreaterThan(mq);
-    }
-  });
-});
-
-describe("Quantizer.getKDtree and getNearest", () => {
-  let img: Uint8Array;
-
-  beforeEach(() => {
-    // small 4-color image
-    img = new Uint8Array([
-      255,
-      0,
-      0,
-      255, // red
-      0,
-      255,
-      0,
-      255, // green
-      0,
-      0,
-      255,
-      255, // blue
-      255,
-      255,
-      0,
-      255, // yellow
-    ]);
-  });
-
-  test("builds KD tree with requested max leaf count", () => {
-    const [root, leafs] = Quantizer.getKDtree(img, 4);
-    expect(root).toHaveProperty("left");
-    expect(root).toHaveProperty("right");
-    expect(Array.isArray(leafs)).toBe(true);
-    expect(leafs.length).toBeLessThanOrEqual(4);
-    // Leaves are sorted by population descending
-    for (let i = 1; i < leafs.length; i++) {
-      expect(leafs[i - 1].bst.N).toBeGreaterThanOrEqual(leafs[i].bst.N);
-    }
-    // Each leaf has an index
-    for (let i = 0; i < leafs.length; i++) {
-      expect(leafs[i].ind).toBe(i);
-    }
-  });
-
-  test("getNearest returns a leaf whose color is close to the query", () => {
-    const [root, leafs] = Quantizer.getKDtree(img, 4);
-    const qColor = [1, 0.1, 0.1, 1]; // close to red
-    const nearest = Quantizer.getNearest(root, qColor[0], qColor[1], qColor[2], qColor[3]);
-
-    expect(leafs.includes(nearest)).toBe(true);
-
-    // Check that returned leaf has reasonable distance to its mean q
-    const dist = Quantizer.dist(nearest.est.q, qColor[0], qColor[1], qColor[2], qColor[3]);
-    expect(dist).toBeLessThan(0.5); // arbitrary sanity bound
-  });
-});
-
-describe("Quantizer palette update and nearest search", () => {
-  test("updatePalette recomputes palette entries as means of assigned pixels", () => {
-    // Image: 4 pixels. First two red-ish, last two green-ish.
-    const sb = new Uint8Array([250, 0, 0, 255, 255, 10, 0, 255, 0, 240, 0, 255, 5, 255, 10, 255]);
-
-    // Two palette entries: start as midpoints
-    const plte = new Uint8Array([
-      128,
-      0,
-      0,
-      255, // approximate red
-      0,
-      128,
-      0,
-      255, // approximate green
-    ]);
-
-    // First two pixels -> index 0, last two -> index 1
-    const inds = new Uint8Array([0, 0, 1, 1]);
-
-    Quantizer.updatePalette(sb, inds, plte);
-
-    // Palette[0] should now be near average of first two reds
-    const avgR0 = Math.round((250 + 255) / 2);
-    const avgG0 = Math.round((0 + 10) / 2);
-    const avgB0 = 0;
-
-    expect(plte[0]).toBe(avgR0);
-    expect(plte[1]).toBe(avgG0);
-    expect(plte[2]).toBe(avgB0);
-
-    // Palette[1] should be near average of two greens
-    const avgR1 = Math.round((0 + 5) / 2);
-    const avgG1 = Math.round((240 + 255) / 2);
-    const avgB1 = Math.round((0 + 10) / 2);
-
-    expect(plte[4]).toBe(avgR1);
-    expect(plte[5]).toBe(avgG1);
-    expect(plte[6]).toBe(avgB1);
-  });
-
-  test("findNearest assigns each pixel to closest palette color and returns average error", () => {
-    const sb = new Uint8Array([
-      255,
-      0,
-      0,
-      255, // red-like
-      0,
-      255,
-      0,
-      255, // green-like
-      0,
-      0,
-      255,
-      255, // blue-like
-    ]);
-
-    // Palette: exact red, green, blue
-    const plte = new Uint8Array([255, 0, 0, 255, 0, 255, 0, 255, 0, 0, 255, 255]);
-
-    const inds = new Uint8Array(sb.length >> 2);
-    // Start with some arbitrary indices
-    inds.fill(0);
-
-    const err = Quantizer.findNearest(sb, inds, plte);
-
-    // Perfect match => each pixel should go to its exact palette index, zero error
-    expect(Array.from(inds)).toEqual([0, 1, 2]);
-    expect(err).toBe(0);
-  });
-
-  test("kmeans runs a single iteration and returns an error value", () => {
-    const sb = new Uint8Array([255, 0, 0, 255, 250, 0, 10, 255, 0, 255, 0, 255, 0, 245, 10, 255]);
-    const plte = new Uint8Array([255, 0, 0, 255, 0, 255, 0, 255]);
-    const inds = new Uint8Array([0, 0, 1, 1]);
-
-    const err = Quantizer.kmeans(sb, inds, plte);
-    expect(err).toBeGreaterThanOrEqual(0);
-    // kmeans mutates palette toward means
-    expect(plte[0]).toBeLessThanOrEqual(255);
-    expect(plte[4]).toBeLessThanOrEqual(255);
-  });
-});
-
-describe("Quantizer.remap", () => {
-  test("remap fills destination buffer from palette using indices", () => {
-    const pl32 = new Uint32Array([
-      0xff0000ff, // red
-      0x00ff00ff, // green
-    ]);
-    const tb32 = new Uint32Array(3);
-    const inds = new Uint8Array([0, 1, 1]);
-
-    Quantizer.remap(inds, tb32, pl32);
-
-    expect(Array.from(tb32)).toEqual([0xff0000ff, 0x00ff00ff, 0x00ff00ff]);
-  });
-});
-
-describe("Quantizer.quantize end-to-end", () => {
-  test("quantizes a tiny image to 2 colors and returns expected shape", () => {
-    // Simple 4-pixel RGBA image: two reds, two greens
-    const img = new Uint8Array([255, 0, 0, 255, 250, 10, 0, 255, 0, 255, 0, 255, 5, 240, 10, 255]);
-    const abuf = img.buffer;
-
-    const ps = 2; // target palette size
-    const result = Quantizer.quantize(abuf, ps, false);
-
-    expect(result).toHaveProperty("abuf");
-    expect(result).toHaveProperty("inds");
-    expect(result).toHaveProperty("plte");
-
-    const out = new Uint8Array(result.abuf);
-    expect(out.length).toBe(img.length);
-    expect(result.inds.length).toBe(img.length / 4);
-    expect(result.plte.length).toBeLessThanOrEqual(ps);
-
-    // Palette entries have est.rgba defined
-    for (const leaf of result.plte) {
-      expect(typeof leaf.est.rgba).toBe("number");
-    }
-
-    // All indices should be < K
-    const K = result.plte.length;
-    for (const idx of result.inds) {
-      expect(idx).toBeLessThan(K);
-    }
-  });
-
-  test("can run with kmeans refinement enabled", () => {
-    const img = new Uint8Array([255, 0, 0, 255, 250, 10, 0, 255, 0, 255, 0, 255, 5, 240, 10, 255]);
-    const result = Quantizer.quantize(img.buffer, 2, true);
-
-    // Same basic structural expectations
-    expect(result.inds.length).toBe(img.length / 4);
-    expect(result.plte.length).toBeLessThanOrEqual(2);
-  });
-});

package/test/upng.test.ts

@@ -1,242 +0,0 @@
-import { describe, expect, test } from "vitest";
-import { UPNG, type Image, type ImageTabs } from "../src/upng.js";
-
-describe("UPNG basic encode/decode", () => {
-  test("round-trips a small opaque RGBA image", async () => {
-    const w = 2;
-    const h = 2;
-    const src = new Uint8Array([
-      255,
-      0,
-      0,
-      255, // red
-      0,
-      255,
-      0,
-      255, // green
-      0,
-      0,
-      255,
-      255, // blue
-      255,
-      255,
-      0,
-      255, // yellow
-    ]);
-    const encoded = await UPNG.encode([src.buffer], w, h, 0);
-    const decoded = UPNG.decode(encoded);
-
-    expect(decoded.width).toBe(w);
-    expect(decoded.height).toBe(h);
-    expect(decoded.frames.length).toBe(1);
-
-    const [rgbaBuf] = UPNG.toRGBA8(decoded);
-    const out = new Uint8Array(rgbaBuf);
-
-    expect(Array.from(out)).toEqual(Array.from(src));
-  });
-
-  test("round-trips an image with transparency (forces alpha ctype 6 or pal+TRNS)", async () => {
-    const w = 2;
-    const h = 2;
-    const buf = new Uint8Array([255, 0, 0, 255, 255, 0, 0, 0, 0, 255, 0, 255, 0, 255, 0, 0]).buffer;
-
-    const encoded = await UPNG.encode([buf], w, h, 0);
-    const decoded = UPNG.decode(encoded);
-    const [rgbaBuf] = UPNG.toRGBA8(decoded);
-    const out = new Uint8Array(rgbaBuf);
-
-    expect(out.length).toBe(w * h * 4);
-    // Colors should match original exactly
-    expect(Array.from(out)).toEqual(Array.from(new Uint8Array(buf)));
-  });
-});
-
-describe("UPNG.toRGBA8", () => {
-  test("returns a single frame buffer for non-animated PNG", async () => {
-    const w = 1;
-    const h = 1;
-    const buf = new Uint8Array([10, 20, 30, 40]).buffer;
-
-    const encoded = await UPNG.encode([buf], w, h, 0);
-    const decoded = UPNG.decode(encoded);
-
-    expect(decoded.tabs.acTL).toBeUndefined();
-
-    const frames = UPNG.toRGBA8(decoded);
-    expect(frames.length).toBe(1);
-    const rgba = new Uint8Array(frames[0]);
-    expect(Array.from(rgba)).toEqual([10, 20, 30, 40]);
-  });
-
-  test("returns buffers for each animation frame and respects blend/dispose", async () => {
-    const w = 2;
-    const h = 1;
-
-    const frame0 = new Uint8Array([255, 0, 0, 255, 0, 255, 0, 255]).buffer;
-    const frame1 = new Uint8Array([0, 0, 255, 255, 255, 255, 255, 255]).buffer;
-
-    const dels = [100, 200];
-    const encoded = await UPNG.encode([frame0, frame1], w, h, 0, dels, { loop: 0 });
-    const decoded = UPNG.decode(encoded);
-
-    expect(decoded.tabs.acTL).toBeDefined();
-    expect(decoded.frames.length).toBe(2);
-
-    const framesRGBA = UPNG.toRGBA8(decoded);
-    expect(framesRGBA.length).toBe(2);
-
-    const f0 = new Uint8Array(framesRGBA[0]);
-    const f1 = new Uint8Array(framesRGBA[1]);
-
-    expect(Array.from(f0)).toEqual(Array.from(new Uint8Array(frame0)));
-    expect(Array.from(f1)).toEqual(Array.from(new Uint8Array(frame1)));
-  });
-});
-
-describe("UPNG.decode ancillary chunks", () => {
-  test("throws on non-PNG magic", () => {
-    const bogus = new Uint8Array([1, 2, 3, 4, 5, 6, 7, 8]).buffer;
-    expect(() => UPNG.decode(bogus)).toThrow(/not a PNG/i);
-  });
-
-  test("parses tEXt & zTXt chunks into tabs", async () => {
-    const w = 1;
-    const h = 1;
-    const buf = new Uint8Array([0, 0, 0, 255]).buffer;
-
-    const tabs: ImageTabs = {
-      tEXt: { Author: "Test" },
-      iTXt: { Comment: "Hello world" },
-    };
-
-    const encoded = await UPNG.encode([buf], w, h, 0, undefined, tabs);
-    const decoded = UPNG.decode(encoded);
-
-    if (decoded.tabs.tEXt) {
-      expect(decoded.tabs.tEXt["Author"]).toBe("Test");
-    }
-    if (decoded.tabs.iTXt) {
-      expect(decoded.tabs.iTXt["Comment"]).toBe("Hello world");
-    }
-  });
-});
-
-describe("UPNG #getBPP and #filterZero via encode/decode", () => {
-  test("handles grayscale (ctype 0) depth 8 correctly", async () => {
-    const w = 3;
-    const h = 1;
-    const gray = new Uint8Array([50, 50, 50, 255, 100, 100, 100, 255, 200, 200, 200, 255]).buffer;
-
-    // Use encodeLL to force grayscale: cc=1, ac=0
-    const encoded = await UPNG.encodeLL([gray], w, h, 1, 0, 8);
-    const decoded = UPNG.decode(encoded);
-    expect(decoded.ctype).toBe(0);
-
-    const [rgbaBuf] = UPNG.toRGBA8(decoded);
-    const out = new Uint8Array(rgbaBuf);
-
-    expect(out[0]).toBe(50);
-    expect(out[1]).toBe(50);
-    expect(out[2]).toBe(50);
-    expect(out[3]).toBe(255);
-    expect(out[4]).toBe(100);
-  });
-
-  test("handles palette-based images (ctype 3) when color count is small", async () => {
-    const w = 2;
-    const h = 2;
-    const buf = new Uint8Array([255, 0, 0, 255, 0, 255, 0, 255, 255, 0, 0, 255, 0, 255, 0, 255])
-      .buffer;
-
-    // Force small palette size to encourage PLTE path
-    const encoded = await UPNG.encode([buf], w, h, 4);
-    const decoded = UPNG.decode(encoded);
-
-    expect(decoded.ctype).toBe(3);
-
-    const [rgbaBuf] = UPNG.toRGBA8(decoded);
-    const out = new Uint8Array(rgbaBuf);
-
-    // Should still decode back to original colors
-    expect(Array.from(out)).toEqual(Array.from(new Uint8Array(buf)));
-  });
-});
-
-describe("UPNG filter/deflate pipeline", () => {
-  test("produces valid data when using filter strategy 0 (none)", async () => {
-    const w = 4;
-    const h = 2;
-    const buf = new Uint8Array(w * h * 4);
-    for (let i = 0; i < buf.length; i += 4) {
-      buf[i] = i & 255;
-      buf[i + 1] = (i * 2) & 255;
-      buf[i + 2] = (i * 3) & 255;
-      buf[i + 3] = 255;
-    }
-
-    // encodeLL with levelZero=true via encodeLL -> #compressPNG(filter=0, levelZero=true)
-    const encoded = await UPNG.encodeLL([buf.buffer], w, h, 3, 1, 8);
-    const decoded = UPNG.decode(encoded);
-    const [rgbaBuf] = UPNG.toRGBA8(decoded);
-    const out = new Uint8Array(rgbaBuf);
-
-    expect(out.length).toBe(buf.length);
-  });
-});
-
-describe("UPNG internal dithering path (by effect)", () => {
-  test("dithers when quantizing with palette (non-empty result)", async () => {
-    const w = 4;
-    const h = 4;
-    const buf = new Uint8Array(w * h * 4);
-    for (let i = 0; i < buf.length; i += 4) {
-      buf[i] = (i / 4) % 256;
-      buf[i + 1] = 255 - ((i / 4) % 256);
-      buf[i + 2] = ((i / 4) * 3) & 255;
-      buf[i + 3] = 255;
-    }
-
-    // cnum=16 palette size, dithering enabled via encode (6th param of prms)
-    const encoded = await (UPNG as any).encode([buf.buffer], w, h, 16, undefined, undefined, false);
-    const decoded = UPNG.decode(encoded);
-    const [rgbaBuf] = UPNG.toRGBA8(decoded);
-    const out = new Uint8Array(rgbaBuf);
-
-    expect(out.length).toBe(buf.length);
-  });
-});
-
-describe("UPNG animated encodeLL", () => {
-  test("encodes multiple frames as an animated PNG with acTL", async () => {
-    const w = 2;
-    const h = 2;
-
-    const frame0 = new Uint8Array([
-      0, 0, 0, 255, 255, 255, 255, 255, 0, 0, 0, 255, 255, 255, 255, 255,
-    ]).buffer;
-
-    const frame1 = new Uint8Array([
-      255, 0, 0, 255, 0, 255, 0, 255, 0, 0, 255, 255, 255, 255, 0, 255,
-    ]).buffer;
-
-    const delays = [100, 200];
-    const tabs = { loop: 0 };
-
-    const encoded = await UPNG.encodeLL([frame0, frame1], w, h, 4, 1, 8, delays, tabs);
-    const decoded = UPNG.decode(encoded) as Image;
-
-    // We should have animation control chunk parsed
-    expect(decoded.tabs.acTL).toBeDefined();
-    expect(decoded.tabs.acTL!.num_frames).toBe(2);
-
-    // We should have two frames decoded
-    expect(decoded.frames.length).toBe(2);
-
-    // Delays should be numbers (not NaN/undefined)
-    expect(typeof decoded.frames[0].delay).toBe("number");
-    expect(typeof decoded.frames[1].delay).toBe("number");
-    expect(decoded.frames[0].delay).toBeGreaterThanOrEqual(0);
-    expect(decoded.frames[1].delay).toBeGreaterThanOrEqual(0);
-  });
-});

package/tsconfig.json

@@ -1,9 +0,0 @@
-{
-	"extends": "../../tsconfig.json",
-  "compilerOptions": {
-    "rootDir": "src",
-    "outDir": "dist"
-  },
-  "include": ["src/**/*"],
-  "exclude": ["dist", "node_modules", "test"]
-}

package/tsconfig.typecheck.json

@@ -1,14 +0,0 @@
-{
-  "extends": "./tsconfig.json",
-  "compilerOptions": {
-    "noEmit": true,
-    "rootDir": "."
-  },
-  "include": [
-    "**/*.ts",
-  ],
-  "exclude": [
-    "dist",
-    "node_modules"
-  ]
-}

package/vitest.config.ts

@@ -1,8 +0,0 @@
-import { defineConfig } from "vitest/config";
-
-export default defineConfig({
-  test: {
-    environment: "node",
-    include: ["test/**/*.test.ts"],
-  },
-});