@chr33s/pdf-upng 5.0.0

package/test/bin.test.ts

@@ -0,0 +1,173 @@
+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

@@ -0,0 +1,71 @@
+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

@@ -0,0 +1,9 @@
+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

@@ -0,0 +1,227 @@
+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);
+  });
+});